Refactored Series List

dbmodels/queries.go

@@ -67,6 +67,15 @@ func REntriesSeries_Entry(app core.App, id string) ([]*REntriesSeries, error) {
 	)
 }
 
+func REntriesSeries_Seriess(app core.App, ids []any) ([]*REntriesSeries, error) {
+	return TableByFields[[]*REntriesSeries](
+		app,
+		RelationTableName(ENTRIES_TABLE, SERIES_TABLE),
+		SERIES_TABLE,
+		ids,
+	)
+}
+
 func Agents_ID(app core.App, id string) (*Agent, error) {
 	r, err := TableByID[Agent](app, AGENTS_TABLE, id)
 	return &r, err
@@ -110,3 +119,8 @@ func Contents_Entry(app core.App, id string) ([]*Content, error) {
 		id,
 	)
 }
+
+func Places_ID(app core.App, id string) (*Place, error) {
+	ret, err := TableByField[Place](app, PLACES_TABLE, ID_FIELD, id)
+	return &ret, err
+}

pages/reihen.go

@@ -7,6 +7,7 @@ import (
 	"github.com/Theodor-Springmann-Stiftung/musenalm/dbmodels"
 	"github.com/Theodor-Springmann-Stiftung/musenalm/pagemodels"
 	"github.com/Theodor-Springmann-Stiftung/musenalm/templating"
+	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/router"
 )
@@ -74,14 +75,12 @@ func (p *ReihenPage) YearRequest(app core.App, engine *templating.Engine, e *cor
 		return engine.Response404(e, err, data)
 	}
 
-	series, relations, entries, err := dbmodels.SeriesForYear(app, y)
+	result, err := NewSeriesResult_Year(app, y)
 	if err != nil {
 		return engine.Response404(e, err, data)
 	}
-	data["entries"] = entries
-	data["relations"] = relations
-	data["series"] = series
 
+	data["result"] = result
 	return p.Get(e, engine, data)
 }
 
@@ -95,21 +94,12 @@ func (p *ReihenPage) LetterRequest(app core.App, engine *templating.Engine, e *c
 	}
 	data[PARAM_LETTER] = letter
 
-	series, err := dbmodels.SeriesForLetter(app, letter)
+	result, err := NewSeriesListResult_Letter(app, letter)
 	if err != nil {
 		return engine.Response404(e, err, data)
 	}
-	// INFO: We sort again since the query can't sort german umlauts correctly
-	dbmodels.Sort_Series_Title(series)
-	data["series"] = series
-
-	rmap, bmap, err := dbmodels.EntriesForSeriesses(app, series)
-	if err != nil {
-		return engine.Response404(e, err, data)
-	}
-	data["entries"] = bmap
-	data["relations"] = rmap
 
+	data["result"] = result
 	return p.Get(e, engine, data)
 }
 
@@ -119,21 +109,12 @@ func (p *ReihenPage) PersonRequest(app core.App, engine *templating.Engine, e *c
 	data[PARAM_PERSON] = person
 	data[PARAM_HIDDEN] = e.Request.URL.Query().Get(PARAM_HIDDEN)
 
-	agent, err := dbmodels.AgentForId(app, person)
+	result, err := NewSeriesResult_Agent(app, person)
 	if err != nil {
 		return engine.Response404(e, err, data)
 	}
-	data["a"] = agent
-
-	series, relations, entries, err := dbmodels.SeriesForAgent(app, person)
-	if err != nil {
-		return engine.Response404(e, err, data)
-	}
-	dbmodels.Sort_Series_Title(series)
-	data["series"] = series
-	data["relations"] = relations
-	data["entries"] = entries
 
+	data["result"] = result
 	return p.Get(e, engine, data)
 }
 
@@ -143,20 +124,12 @@ func (p *ReihenPage) PlaceRequest(app core.App, engine *templating.Engine, e *co
 	data[PARAM_PLACE] = place
 	data[PARAM_HIDDEN] = e.Request.URL.Query().Get(PARAM_HIDDEN)
 
-	pl, err := dbmodels.PlaceForId(app, place)
+	result, err := NewSeriesResult_Place(app, place)
 	if err != nil {
 		return engine.Response404(e, err, data)
 	}
-	data["p"] = pl
-
-	series, relations, entries, err := dbmodels.SeriesForPlace(app, place)
-	if err != nil {
-		return engine.Response404(e, err, data)
-	}
-	data["series"] = series
-	data["relations"] = relations
-	data["entries"] = entries
 
+	data["result"] = result
 	return p.Get(e, engine, data)
 }
 
@@ -166,25 +139,320 @@ func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *c
 	data := map[string]interface{}{}
 	data[PARAM_SEARCH] = search
 
-	// INFO: normalization happens in the db query
+	result, err := NewSeriesResult_Search(app, search)
-	series, altseries, err := dbmodels.BasicSearchSeries(app, search)
-
 	if err != nil {
 		return engine.Response404(e, err, data)
 	}
+
+	data["result"] = result
+	return p.Get(e, engine, data)
+}
+
+func (p *ReihenPage) Get(request *core.RequestEvent, engine *templating.Engine, data map[string]interface{}) error {
+	data["common"] = NewCommonReihenData(request.App)
+	return engine.Response200(request, URL_REIHEN, data)
+}
+
+type CommonReihenData struct {
+	Years   []int
+	Places  []*dbmodels.Place
+	Letters []string
+	Agents  []*dbmodels.Agent
+}
+
+func NewCommonReihenData(app core.App) CommonReihenData {
+	arels := []*core.Record{}
+	err := app.RecordQuery(
+		dbmodels.RelationTableName(dbmodels.ENTRIES_TABLE, dbmodels.AGENTS_TABLE)).
+		GroupBy(dbmodels.AGENTS_TABLE).
+		All(&arels)
+	if err != nil {
+		app.Logger().Error("Failed to fetch agents", "error", err)
+	}
+
+	ids := []any{}
+	for _, a := range arels {
+		ids = append(ids, a.GetString(dbmodels.AGENTS_TABLE))
+	}
+
+	agents, err := dbmodels.Agents_IDs(app, ids)
+	if err != nil {
+		app.Logger().Error("Failed to fetch agents", "error", err)
+	}
+
+	letterrecs := []core.Record{}
+	letters := []string{}
+
+	err = app.RecordQuery(dbmodels.SERIES_TABLE).
+		Select("upper(substr(" + dbmodels.SERIES_TITLE_FIELD + ", 1, 1)) AS id").
+		Distinct(true).
+		OrderBy("id").
+		All(&letterrecs)
+	if err != nil {
+		app.Logger().Error("Failed to fetch letters", "error", err)
+	}
+
+	for _, l := range letterrecs {
+		letters = append(letters, l.GetString("id"))
+	}
+
+	places := []*dbmodels.Place{}
+	err = app.RecordQuery(dbmodels.PLACES_TABLE).
+		OrderBy(dbmodels.PLACES_NAME_FIELD).
+		All(&places)
+	if err != nil {
+		app.Logger().Error("Failed to fetch places", "error", err)
+	}
+	dbmodels.SortPlacesByName(places)
+
+	rec := []core.Record{}
+	err = app.RecordQuery(dbmodels.ENTRIES_TABLE).
+		Select(dbmodels.YEAR_FIELD + " AS id").
+		Distinct(true).
+		OrderBy("id").
+		All(&rec)
+	if err != nil {
+		app.Logger().Error("Failed to fetch years", "error", err)
+	}
+
+	years := []int{}
+	for _, r := range rec {
+		years = append(years, r.GetInt("id"))
+	}
+
+	return CommonReihenData{
+		Years:   years,
+		Places:  places,
+		Letters: letters,
+		Agents:  agents,
+	}
+}
+
+type SeriesListResult struct {
+	Series        []*dbmodels.Series
+	Entries       map[string]*dbmodels.Entry            // <-- Key is Entry.ID
+	EntriesSeries map[string][]*dbmodels.REntriesSeries // <-- Key is Series.ID
+
+	// INFO: Only on agent request
+	Agent         *dbmodels.Agent
+	EntriesAgents map[string][]*dbmodels.REntriesAgents // <-- Key is Entry.ID
+
+	// INFO: Only on search request
+	IDSeries  []*dbmodels.Series
+	AltSeries []*dbmodels.Series
+
+	// INFO: Only on place request
+	Place *dbmodels.Place
+}
+
+func NewSeriesListResult_Letter(app core.App, letter string) (*SeriesListResult, error) {
+	series := []*dbmodels.Series{}
+	err := app.RecordQuery(dbmodels.SERIES_TABLE).
+		Where(dbx.Like(dbmodels.SERIES_TITLE_FIELD, letter).Match(false, true)).
+		OrderBy(dbmodels.SERIES_TITLE_FIELD).
+		All(&series)
+	if err != nil {
+		return nil, err
+	}
 	dbmodels.Sort_Series_Title(series)
-	dbmodels.Sort_Series_Title(altseries)
+
-	data["series"] = series
+	relations, err := dbmodels.REntriesSeries_Seriess(app, dbmodels.Ids(series))
-	data["altseries"] = altseries
+	if err != nil {
+		return nil, err
+	}
+
+	eids := []any{}
+	relationsMap := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range relations {
+		relationsMap[r.Series()] = append(relationsMap[r.Series()], r)
+		eids = append(eids, r.Entry())
+	}
+
+	entries, err := dbmodels.Entries_IDs(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesMap := map[string]*dbmodels.Entry{}
+	for _, e := range entries {
+		entriesMap[e.Id] = e
+	}
 
 	rmap, bmap, err := dbmodels.EntriesForSeriesses(app, series)
 	if err != nil {
-		return engine.Response404(e, err, data)
+		return nil, err
+	}
+
+	return &SeriesListResult{
+		Series:        series,
+		Entries:       bmap,
+		EntriesSeries: rmap,
+	}, nil
+}
+
+func NewSeriesResult_Agent(app core.App, person string) (*SeriesListResult, error) {
+	agent, err := dbmodels.Agents_ID(app, person)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesagentsrels, err := dbmodels.REntriesAgents_Agent(app, agent.Id)
+	if err != nil {
+		return nil, err
+	}
+
+	eids := []any{}
+	entriesagents := map[string][]*dbmodels.REntriesAgents{}
+	for _, r := range entriesagentsrels {
+		eids = append(eids, r.Entry())
+		entriesagents[r.Entry()] = append(entriesagents[r.Entry()], r)
+	}
+
+	entries, err := dbmodels.Entries_IDs(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesMap := map[string]*dbmodels.Entry{}
+	for _, e := range entries {
+		entriesMap[e.Id] = e
+	}
+
+	entriesseriesrels, err := dbmodels.REntriesSeries_Entries(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	sids := []any{}
+	entriesseries := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range entriesseriesrels {
+		sids = append(sids, r.Series())
+		entriesseries[r.Series()] = append(entriesseries[r.Series()], r)
+	}
+
+	series, err := dbmodels.Series_IDs(app, sids)
+	if err != nil {
+		return nil, err
+	}
+
+	dbmodels.Sort_Series_Title(series)
+
+	return &SeriesListResult{
+		Series:        series,
+		Entries:       entriesMap,
+		EntriesSeries: entriesseries,
+		Agent:         agent,
+		EntriesAgents: entriesagents,
+	}, nil
+}
+
+func NewSeriesResult_Year(app core.App, year int) (*SeriesListResult, error) {
+	entries := []*dbmodels.Entry{}
+	err := app.RecordQuery(dbmodels.ENTRIES_TABLE).
+		Where(dbx.HashExp{dbmodels.YEAR_FIELD: year}).
+		All(&entries)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesMap := map[string]*dbmodels.Entry{}
+	eids := []any{}
+	for _, e := range entries {
+		eids = append(eids, e.Id)
+		entriesMap[e.Id] = e
+	}
+
+	entriesseriesrels, err := dbmodels.REntriesSeries_Entries(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	sids := []any{}
+	entriesseries := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range entriesseriesrels {
+		sids = append(sids, r.Series())
+		entriesseries[r.Series()] = append(entriesseries[r.Series()], r)
+	}
+
+	series, err := dbmodels.Series_IDs(app, sids)
+	if err != nil {
+		return nil, err
+	}
+
+	dbmodels.Sort_Series_Title(series)
+
+	return &SeriesListResult{
+		Series:        series,
+		Entries:       entriesMap,
+		EntriesSeries: entriesseries,
+	}, nil
+}
+
+func NewSeriesResult_Place(app core.App, place string) (*SeriesListResult, error) {
+	p, err := dbmodels.Places_ID(app, place)
+	if err != nil {
+		return nil, err
+	}
+
+	entries := []*dbmodels.Entry{}
+	err = app.RecordQuery(dbmodels.ENTRIES_TABLE).
+		Where(dbx.Like(dbmodels.PLACES_TABLE, place).Match(true, true)).
+		All(&entries)
+	if err != nil {
+		return nil, err
+	}
+
+	entriesMap := map[string]*dbmodels.Entry{}
+	eids := []any{}
+	for _, e := range entries {
+		eids = append(eids, e.Id)
+		entriesMap[e.Id] = e
+	}
+
+	entriesseriesrels, err := dbmodels.REntriesSeries_Entries(app, eids)
+	if err != nil {
+		return nil, err
+	}
+
+	sids := []any{}
+	entriesseries := map[string][]*dbmodels.REntriesSeries{}
+	for _, r := range entriesseriesrels {
+		sids = append(sids, r.Series())
+		entriesseries[r.Series()] = append(entriesseries[r.Series()], r)
+	}
+
+	series, err := dbmodels.Series_IDs(app, sids)
+	if err != nil {
+		return nil, err
+	}
+
+	dbmodels.Sort_Series_Title(series)
+
+	return &SeriesListResult{
+		Series:        series,
+		Entries:       entriesMap,
+		EntriesSeries: entriesseries,
+		Place:         p,
+	}, nil
+}
+
+func NewSeriesResult_Search(app core.App, search string) (*SeriesListResult, error) {
+	series, altseries, err := dbmodels.BasicSearchSeries(app, search)
+	if err != nil {
+		return nil, err
+	}
+
+	dbmodels.Sort_Series_Title(series)
+	dbmodels.Sort_Series_Title(altseries)
+
+	rmap, bmap, err := dbmodels.EntriesForSeriesses(app, series)
+	if err != nil {
+		return nil, err
 	}
 
 	rmap2, bmap2, err := dbmodels.EntriesForSeriesses(app, altseries)
 	if err != nil {
-		return engine.Response404(e, err, data)
+		return nil, err
 	}
 
 	for k, v := range rmap2 {
@@ -194,26 +462,23 @@ func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *c
 		bmap[k] = v
 	}
 
-	// Searching for MUSENALM-ID
+	ids := []*dbmodels.Series{}
 	if searchint, err := strconv.Atoi(search); err == nil {
 		identries, err := dbmodels.EntriesForID(app, searchint)
 		if err != nil {
-			return engine.Response404(e, err, data)
+			return nil, err
 		}
 
 		if len(identries) != 0 {
 
 			idseries, rmap3, bmap3, err := dbmodels.SeriesForEntries(app, identries)
 			if err != nil {
-				return engine.Response404(e, err, data)
+				return nil, err
 			}
 
+			ids = idseries
+
 			dbmodels.Sort_Series_Title(idseries)
-			data["idseries"] = idseries
-
-			if err != nil {
-				return engine.Response404(e, err, data)
-			}
 
 			for k, v := range rmap3 {
 				rmap[k] = v
@@ -225,52 +490,11 @@ func (p *ReihenPage) SearchRequest(app core.App, engine *templating.Engine, e *c
 		}
 	}
 
-	data["entries"] = bmap
+	return &SeriesListResult{
-	data["relations"] = rmap
+		Series:        series,
-
+		Entries:       bmap,
-	return p.Get(e, engine, data)
+		EntriesSeries: rmap,
-}
+		IDSeries:      ids,
-
+		AltSeries:     altseries,
-func (p *ReihenPage) CommonData(app core.App, data map[string]interface{}) error {
+	}, nil
-	agents, err := dbmodels.AllAgentsForSeries(app)
-	if err != nil {
-		return err
-	}
-	data["agents"] = agents
-
-	letters, err := dbmodels.LettersForSeries(app)
-	if err != nil {
-		return err
-	}
-	data["letters"] = letters
-
-	places, err := dbmodels.AllPlaces(app)
-	if err != nil {
-		return err
-	}
-	dbmodels.SortPlacesByName(places)
-	data["places"] = places
-
-	years, err := dbmodels.YearsForEntries(app)
-	if err != nil {
-		return err
-	}
-	data["years"] = years
-
-	record, err := p.GetLatestData(app)
-	if err != nil {
-		return err
-	}
-
-	data["record"] = pagemodels.NewReihen(record)
-	return nil
-}
-
-func (p *ReihenPage) Get(request *core.RequestEvent, engine *templating.Engine, data map[string]interface{}) error {
-	err := p.CommonData(request.App, data)
-	if err != nil {
-		return engine.Response404(request, err, data)
-	}
-
-	return engine.Response200(request, URL_REIHEN, data)
 }

views/assets/scripts.js

@@ -1,494 +0,0 @@
-var _ = (s) => {
-  throw TypeError(s);
-};
-var T = (s, e, t) => e.has(s) || _("Cannot " + t);
-var f = (s, e, t) => (T(s, e, "read from private field"), t ? t.call(s) : e.get(s)), c = (s, e, t) => e.has(s) ? _("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(s) : e.set(s, t), d = (s, e, t, i) => (T(s, e, "write to private field"), i ? i.call(s, t) : e.set(s, t), t), g = (s, e, t) => (T(s, e, "access private method"), t);
-const k = "script[xslt-onload]", v = "xslt-template", w = "xslt-transformed", A = "filter-list", m = "filter-list-list", M = "filter-list-item", y = "filter-list-input", x = "filter-list-searchable", B = "scroll-button", I = "tool-tip", P = "abbrev-tooltips", C = "int-link";
-var h, b, E;
-class z {
-  constructor() {
-    c(this, b);
-    c(this, h);
-    d(this, h, /* @__PURE__ */ new Map());
-  }
-  setup() {
-    let e = htmx.findAll(k);
-    for (let t of e)
-      g(this, b, E).call(this, t);
-  }
-  hookupHTMX() {
-    htmx.on("htmx:load", (e) => {
-      this.setup();
-    });
-  }
-}
-h = new WeakMap(), b = new WeakSet(), E = function(e) {
-  if (e.getAttribute(w) === "true" || !e.hasAttribute(v))
-    return;
-  let t = "#" + e.getAttribute(v), i = f(this, h).get(t);
-  if (!i) {
-    let l = htmx.find(t);
-    if (l) {
-      let S = l.innerHTML ? new DOMParser().parseFromString(l.innerHTML, "application/xml") : l.contentDocument;
-      i = new XSLTProcessor(), i.importStylesheet(S), f(this, h).set(t, i);
-    } else
-      throw new Error("Unknown XSLT template: " + t);
-  }
-  let r = new DOMParser().parseFromString(e.innerHTML, "application/xml"), n = i.transformToFragment(r, document), o = new XMLSerializer().serializeToString(n);
-  e.outerHTML = o;
-};
-var a, p, L;
-class H extends HTMLElement {
-  constructor() {
-    super();
-    c(this, p);
-    c(this, a, !1);
-    this._items = [], this._url = "", this._filterstart = !1, this._placeholder = "Liste filtern...", this.render();
-  }
-  static get observedAttributes() {
-    return ["data-url"];
-  }
-  set items(t) {
-    Array.isArray(t) && (this._items = t, this.render());
-  }
-  get items() {
-    return this._items;
-  }
-  connectedCallback() {
-    this._url = this.getAttribute("data-url") || "./", this._filterstart = this.getAttribute("data-filterstart") === "true", this._placeholder = this.getAttribute("data-placeholder") || "Liste filtern...", this._filterstart && d(this, a, !0), this.addEventListener("input", this.onInput.bind(this)), this.addEventListener("keydown", this.onEnter.bind(this)), this.addEventListener("focusin", this.onGainFocus.bind(this)), this.addEventListener("focusout", this.onLoseFocus.bind(this));
-  }
-  attributeChangedCallback(t, i, r) {
-    t === "data-url" && i !== r && (this._url = r, this.render()), t === "data-filterstart" && i !== r && (this._filterstart = r === "true", this.render()), t === "data-placeholder" && i !== r && (this._placeholder = r, this.render());
-  }
-  onInput(t) {
-    t.target && t.target.tagName.toLowerCase() === "input" && (this._filter = t.target.value, this.renderList());
-  }
-  onGainFocus(t) {
-    t.target && t.target.tagName.toLowerCase() === "input" && (d(this, a, !1), this.renderList());
-  }
-  onLoseFocus(t) {
-    let i = this.querySelector("input");
-    if (t.target && t.target === i) {
-      if (relatedElement = t.relatedTarget, relatedElement && this.contains(relatedElement))
-        return;
-      i.value = "", this._filter = "", this._filterstart && d(this, a, !0), this.renderList();
-    }
-  }
-  onEnter(t) {
-    if (t.target && t.target.tagName.toLowerCase() === "input" && t.key === "Enter") {
-      t.preventDefault();
-      const i = this.querySelector("a");
-      i && i.click();
-    }
-  }
-  mark() {
-    if (typeof Mark != "function")
-      return;
-    let t = this.querySelector("#" + m);
-    if (!t)
-      return;
-    let i = new Mark(t.querySelectorAll("." + x));
-    this._filter && i.mark(this._filter, {
-      separateWordSearch: !0
-    });
-  }
-  // INFO: allows for setting a custom HREF of the list item
-  // The function takes the item as parameter fn(item) and should return a string.
-  setHREFFunc(t) {
-    this.getHREF = t, this.render();
-  }
-  // INFO: allows for setting a custom link text of the list item
-  // The function takes the item as parameter fn(item) and should return a string or
-  // an HTML template literal.
-  setLinkTextFunc(t) {
-    this.getLinkText = t, this.render();
-  }
-  // INFO: allows for setting the text that will be filtered for.
-  // The function takes the item as parameter fn(item) and should return a string.
-  setSearchTextFunc(t) {
-    this.getSearchText = t, this.render();
-  }
-  getHREF(t) {
-    if (t) {
-      if (!t.id)
-        return "";
-    } else return "";
-    return t.id;
-  }
-  getSearchText(t) {
-    if (t) {
-      if (!t.name)
-        return "";
-    } else return "";
-    return t.name;
-  }
-  getLinkText(t) {
-    let i = this.getSearchText(t);
-    return i === "" ? "" : `<span class="${x}">${i}</span>`;
-  }
-  renderList() {
-    let t = this.querySelector("#" + m);
-    t && (t.outerHTML = this.List()), this.mark();
-  }
-  render() {
-    this.innerHTML = `
-            <div class="font-serif text-base shadow-inner border border-stone-100">
-							${this.Input()}
-							${this.List()}
-            </div>
-        `;
-  }
-  ActiveDot(t) {
-    return g(this, p, L).call(this, t), "";
-  }
-  NoItems(t) {
-    return t.length === 0 ? '<div class="px-2 py-0.5 italic text-gray-500">Keine Einträge gefunden</div>' : "";
-  }
-  Input() {
-    return `
-			<div class="flex w-full py-0.5 border-b border-zinc-600 bg-stone-50">
-						<i class="ri-arrow-right-s-line pl-2"></i>
-						<div class="grow">
-						<input
-								type="text"
-								placeholder="${this._placeholder}"
-								class="${y} w-full placeholder:italic px-2 py-0.5" />
-						</div>
-				</div>
-				`;
-  }
-  List() {
-    let t = this._items;
-    if (this._filter)
-      if (this._filterstart)
-        t = this._items.filter((i) => this.getSearchText(i).toLowerCase().startsWith(this._filter.toLowerCase()));
-      else {
-        let i = this._filter.split(" ");
-        t = this._items.filter((r) => i.every((n) => this.getSearchText(r).toLowerCase().includes(n.toLowerCase())));
-      }
-    return `
-							<div id="${m}" class="${m} pt-1 min-h-[19rem] max-h-60 overflow-auto border-b border-zinc-300 bg-stone-50 ${f(this, a) ? "hidden" : ""}">
-								${t.map(
-      (i, r) => `
-									<a
-										href="${this._url}${this.getHREF(i)}"
-										class="${M} block px-2.5 py-0.5 hover:bg-slate-200 no-underline ${r % 2 === 0 ? "bg-stone-100" : "bg-stone-50"}"
-										${g(this, p, L).call(this, i) ? 'aria-current="page"' : ""}>
-										${this.ActiveDot(i)}
-										${this.getLinkText(i)}
-									</a>
-								`
-    ).join("")}
-								${this.NoItems(t)}
-							</div>
-				`;
-  }
-}
-a = new WeakMap(), p = new WeakSet(), L = function(t) {
-  if (!t)
-    return !1;
-  let i = this.getHREF(t);
-  return !(i === "" || !window.location.href.endsWith(i));
-};
-class $ extends HTMLElement {
-  constructor() {
-    super(), this.handleScroll = this.handleScroll.bind(this), this.scrollToTop = this.scrollToTop.bind(this);
-  }
-  connectedCallback() {
-    this.innerHTML = `
-          <button
-            class="
-              scroll-to-top
-              fixed bottom-5 right-5
-              hidden
-              bg-gray-800 text-white
-              p-2
-              rounded-md
-              cursor-pointer
-              text-2xl
-              hover:opacity-80
-              transition-opacity
-              border-0
-            "
-            aria-label="Scroll to top"
-          >
-					<i class="ri-arrow-up-double-line"></i>
-          </button>
-        `, this._button = this.querySelector(".scroll-to-top"), window.addEventListener("scroll", this.handleScroll), this._button.addEventListener("click", this.scrollToTop);
-  }
-  disconnectedCallback() {
-    window.removeEventListener("scroll", this.handleScroll), this._button.removeEventListener("click", this.scrollToTop);
-  }
-  handleScroll() {
-    (window.scrollY || document.documentElement.scrollTop) > 300 ? this._button.classList.remove("hidden") : this._button.classList.add("hidden");
-  }
-  scrollToTop() {
-    window.scrollTo({ top: 0, behavior: "smooth" });
-  }
-}
-class F extends HTMLElement {
-  static get observedAttributes() {
-    return ["position", "timeout"];
-  }
-  constructor() {
-    super(), this._tooltipBox = null, this._timeout = 200, this._hideTimeout = null, this._hiddenTimeout = null;
-  }
-  connectedCallback() {
-    this.classList.add(
-      "w-full",
-      "h-full",
-      "relative",
-      "block",
-      "leading-none",
-      "[&>*]:leading-normal"
-    );
-    const e = this.querySelector(".data-tip"), t = e ? e.innerHTML : "Tooltip";
-    e && e.remove(), this._tooltipBox = document.createElement("div"), this._tooltipBox.innerHTML = t, this._tooltipBox.className = [
-      "opacity-0",
-      "hidden",
-      "absolute",
-      "px-2",
-      "py-1",
-      "text-sm",
-      "text-white",
-      "bg-gray-900",
-      "rounded",
-      "shadow",
-      "z-10",
-      "whitespace-nowrap",
-      "transition-all",
-      "duration-200",
-      "font-sans"
-    ].join(" "), this.appendChild(this._tooltipBox), this._updatePosition(), this.addEventListener("mouseenter", () => this._showTooltip()), this.addEventListener("mouseleave", () => this._hideTooltip());
-  }
-  attributeChangedCallback(e, t, i) {
-    e === "position" && this._tooltipBox && this._updatePosition(), e === "timeout" && i && (this._timeout = parseInt(i) || 200);
-  }
-  _showTooltip() {
-    clearTimeout(this._hideTimeout), clearTimeout(this._hiddenTimeout), this._tooltipBox.classList.remove("hidden"), setTimeout(() => {
-      this._tooltipBox.classList.remove("opacity-0"), this._tooltipBox.classList.add("opacity-100");
-    }, 16);
-  }
-  _hideTooltip() {
-    this._hideTimeout = setTimeout(() => {
-      this._tooltipBox.classList.remove("opacity-100"), this._tooltipBox.classList.add("opacity-0"), this._hiddenTimeout = setTimeout(() => {
-        this._tooltipBox.classList.add("hidden");
-      }, this._timeout + 100);
-    }, this._timeout);
-  }
-  _updatePosition() {
-    switch (this._tooltipBox.classList.remove(
-      "bottom-full",
-      "left-1/2",
-      "-translate-x-1/2",
-      "mb-2",
-      // top
-      "top-full",
-      "mt-2",
-      // bottom
-      "right-full",
-      "-translate-y-1/2",
-      "mr-2",
-      "top-1/2",
-      // left
-      "left-full",
-      "ml-2"
-      // right
-    ), this.getAttribute("position") || "top") {
-      case "bottom":
-        this._tooltipBox.classList.add(
-          "top-full",
-          "left-1/2",
-          "transform",
-          "-translate-x-1/2",
-          "mt-0.5"
-        );
-        break;
-      case "left":
-        this._tooltipBox.classList.add(
-          "right-full",
-          "top-1/2",
-          "transform",
-          "-translate-y-1/2",
-          "mr-0.5"
-        );
-        break;
-      case "right":
-        this._tooltipBox.classList.add(
-          "left-full",
-          "top-1/2",
-          "transform",
-          "-translate-y-1/2",
-          "ml-0.5"
-        );
-        break;
-      case "top":
-      default:
-        this._tooltipBox.classList.add(
-          "bottom-full",
-          "left-1/2",
-          "transform",
-          "-translate-x-1/2",
-          "mb-0.5"
-        );
-    }
-  }
-}
-class u extends HTMLElement {
-  static get observedAttributes() {
-    return ["data-text", "data-abbrevmap"];
-  }
-  static get defaultAbbrevMap() {
-    return {
-      "#": "Hinweis auf weitere Informationen in der Anmerkung.",
-      $: "vermutlich",
-      "+++": "Inhalte aus mehreren Almanachen interpoliert",
-      B: "Blatt",
-      BB: "Blätter",
-      C: "Corrigenda",
-      Diagr: "Diagramm",
-      G: "Graphik",
-      "G-Verz": "Verzeichnis der Kupfer u. ä.",
-      GG: "Graphiken",
-      Hrsg: "Herausgeber",
-      "I-Verz": "Inhaltsverzeichnis",
-      Kal: "Kalendarium",
-      Kr: "Karte",
-      MusB: "Musikbeigabe",
-      MusBB: "Musikbeigaben",
-      S: "Seite",
-      SS: "Seiten",
-      Sp: "Spiegel",
-      T: "Titel",
-      TG: "Titelgraphik, Titelportrait etc",
-      "TG r": "Titelgraphik, Titelportrait etc recto",
-      "TG v": "Titelgraphik, Titelportrait etc verso",
-      Tab: "Tabelle",
-      UG: "Umschlaggraphik",
-      "UG r": "Umschlaggraphik recto",
-      "UG v": "Umschlaggraphik verso",
-      VB: "Vorsatzblatt",
-      Vf: "Verfasser",
-      VrlgM: "Verlagsmitteilung",
-      Vrwrt: "Vorwort",
-      ar: "arabische Paginierung",
-      ar1: "erste arabische Paginierung",
-      ar2: "zweite arabische Paginierung",
-      ar3: "dritte arabische Paginierung",
-      ar4: "vierte arabische Paginierung",
-      ar5: "fünfte arabische Paginierung",
-      ar6: "sechste arabische Paginierung",
-      ar7: "siebte arabische Paginierung",
-      gA: "graphische Anleitung",
-      gT: "graphischer Titel",
-      gTzA: "graphische Tanzanleitung",
-      nT: "Nachtitel",
-      röm: "römische Paginierung",
-      röm1: "erste römische Paginierung",
-      röm2: "zweite römische Paginierung",
-      röm3: "dritte römische Paginierung",
-      röm4: "vierte römische Paginierung",
-      röm5: "fünfte römische Paginierung",
-      röm6: "sechste römische Paginierung",
-      röm7: "siebte römische Paginierung",
-      vT: "Vortitel",
-      zT: "Zwischentitel",
-      "§§": "Hinweis auf Mängel im Almanach (Beschädigungen, fehlende Graphiken, unvollständige Sammlungen etc) in der Anmerkung"
-    };
-  }
-  constructor() {
-    super(), this._abbrevMap = u.defaultAbbrevMap;
-  }
-  connectedCallback() {
-    this.render();
-  }
-  attributeChangedCallback(e, t, i) {
-    t !== i && (e === "data-abbrevmap" && this._parseAndSetAbbrevMap(i), this.render());
-  }
-  _parseAndSetAbbrevMap(e) {
-    if (!e) {
-      this._abbrevMap = u.defaultAbbrevMap;
-      return;
-    }
-    try {
-      this._abbrevMap = JSON.parse(e);
-    } catch {
-      this._abbrevMap = u.defaultAbbrevMap;
-    }
-  }
-  setAbbrevMap(e) {
-    typeof e == "object" && e !== null && (this._abbrevMap = e, this.render());
-  }
-  get text() {
-    return this.getAttribute("data-text") || "";
-  }
-  set text(e) {
-    this.setAttribute("data-text", e);
-  }
-  render() {
-    this.innerHTML = this.transformText(this.text, this._abbrevMap);
-  }
-  transformText(e, t) {
-    let i = "", r = 0;
-    for (; r < e.length; ) {
-      if (r > 0 && !this.isSpaceOrPunct(e[r - 1])) {
-        i += e[r], r++;
-        continue;
-      }
-      const n = this.findLongestAbbrevAt(e, r, t);
-      if (n) {
-        const { match: o, meaning: l } = n;
-        i += `
-            <tool-tip position="top" class="!inline" timeout="300">
-              <div class="data-tip p-2 text-sm text-white bg-gray-700 rounded shadow">
-                ${l}
-              </div>
-              <span class="cursor-help text-blue-900 hover:text-slate-800">
-                ${o}
-              </span>
-            </tool-tip>
-          `, r += o.length;
-      } else
-        i += e[r], r++;
-    }
-    return i;
-  }
-  findLongestAbbrevAt(e, t, i) {
-    let r = null, n = 0;
-    for (const o of Object.keys(i))
-      e.startsWith(o, t) && o.length > n && (r = o, n = o.length);
-    return r ? { match: r, meaning: i[r] } : null;
-  }
-  isSpaceOrPunct(e) {
-    return /\s|[.,;:!?]/.test(e);
-  }
-}
-class N extends HTMLElement {
-  constructor() {
-    super();
-  }
-  connectedCallback() {
-    this.style.cursor = "pointer", this.addEventListener("click", this.handleClick);
-  }
-  disconnectedCallback() {
-    this.removeEventListener("click", this.handleClick);
-  }
-  handleClick(e) {
-    const t = this.getAttribute("data-jump");
-    if (t) {
-      const i = document.querySelector(t);
-      i ? i.scrollIntoView({ behavior: "smooth" }) : console.warn(`No element found for selector: ${t}`);
-    }
-  }
-}
-customElements.define(C, N);
-customElements.define(P, u);
-customElements.define(A, H);
-customElements.define(B, $);
-customElements.define(I, F);
-export {
-  u as AbbreviationTooltips,
-  H as FilterList,
-  $ as ScrollButton,
-  z as XSLTParseProcess
-};

views/routes/reihen/body.gohtml

@@ -1,3 +1,30 @@
+{{/* .common
+	type CommonReihenData struct {
+	Years   []int
+	Places  []*dbmodels.Place
+	Letters []string
+	Agents  []*dbmodels.Agent
+	}
+
+	.result
+	type SeriesListResult struct {
+	Series        []*dbmodels.Series
+	Entries       map[string]*dbmodels.Entry            // <-- Key is Entry.ID
+	EntriesSeries map[string][]*dbmodels.REntriesSeries // <-- Key is Series.ID
+
+	// Only on agent request
+	Agent         *dbmodels.Agent
+	EntriesAgents map[string][]*dbmodels.REntriesAgents // <-- Key is Entry.ID
+
+	// Only on search request
+	IDSeries  []*dbmodels.Series
+	AltSeries []*dbmodels.Series
+
+	// Only on place request
+	Place *dbmodels.Place
+	}
+	*/}}
+
 {{ $model := . }}
 {{ if and .startpage .record }}
 	{{ template "hero" . }}
@@ -13,7 +40,7 @@
 
 		{{ if not (or .search .hidden) }}
 			<div class="mt-2">
-				{{ template "alphabet" Dict "active" .letter "letters" .letters "search" .search }}
+				{{ template "alphabet" Dict "active" .letter "letters" $model.common.Letters "search" .search }}
 			</div>
 		{{ else }}
 			<div class="mt-2 border-b w-full"></div>
@@ -34,25 +61,26 @@
 
 		<!-- INFO: 3. Treffer -->
 		<div id="searchcontent" class="font-serif">
-			{{ if and .search .idseries }}
+			{{ if and .search $model.result.IDSeries }}
 				<div class="mb-1 max-w-[60rem] hyphens-auto">
-					{{ range $id, $r := .idseries }}
+					{{ range $id, $r := $model.result.IDSeries }}
-						{{ template "_reihe" (Arr $r $model.entries $model.relations true false false) }}
+						{{ template "_reihe" (Arr $r $model.result.Entries $model.result.EntriesSeries true false false) }}
 					{{ end }}
 				</div>
 			{{ end }}
-			{{ if .series }}
+
+			{{ if $model.result.Series }}
 				<div class="mb-1 max-w-[60rem] hyphens-auto">
-					{{ range $id, $r := .series }}
+					{{ range $id, $r := $model.result.Series }}
-						{{ template "_reihe" (Arr $r $model.entries $model.relations false false
+						{{ template "_reihe" (Arr $r $model.result.Entries $model.result.EntriesSeries false false
 							false)
 						}}
 					{{ end }}
 				</div>
 			{{ end }}
 
-			{{ if and .search .altseries }}
+			{{ if and .search $model.result.AltSeries }}
-				{{ if .idseries }}
+				{{ if $model.result.IDSeries }}
 					<div class="border-b text-sm font-sans text-right pb-0.5">
 						Treffer in Almanach-Nummer &uarr;
 					</div>
@@ -64,7 +92,7 @@
 					</div>
 				{{ end }}
 
-				{{ if not (or .series .idseries) }}
+				{{ if not (or $model.result.Series $model.result.IDSeries) }}
 					<div class="border-b text-sm font-sans text-right pb-0.5">
 						Keine Treffer im Reihentitel
 						<i class="ri-forbid-line inline-bloc -mr-0.5"></i>
@@ -74,12 +102,12 @@
 					Treffer in allen Feldern (inkl. Anmerkungen &amp; Verweise) &darr;
 				</div>
 				<div class="mb-1 max-w-[60rem] hyphens-auto">
-					{{ range $id, $r := .altseries }}
+					{{ range $id, $r := $model.result.AltSeries }}
-						{{ template "_reihe" (Arr $r $model.entries $model.relations false true true) }}
+						{{ template "_reihe" (Arr $r $model.result.Entries $model.result.EntriesSeries false true true) }}
 					{{ end }}
 				</div>
 			{{ end }}
-			{{ if not (or .series .altseries .idseries) }}
+			{{ if not (or $model.result.Series $model.result.AltSeries $model.result.IDSeries) }}
 				<div class="mt-8">
 					Keine Reihen
 					{{ if .search }}für {{ .search }}{{ end }}

views/routes/reihen/components/filter.gohtml

@@ -2,7 +2,7 @@
 <div
 	class="hidden lg:flex min-w-[32rem] max-w-[32rem] float-right ml-6 flex-col gap-y-8 [&>*]:pb-12
 	[&>*]:px-12 [&>*]:pt-8 [&>*]:bg-slate-100">
-	{{ if .agents }}
+	{{ if $model.common.Agents }}
 		<div class="">
 			<h2 class="mb-6">Herausgeber:innen, Verlage &amp; Druckereien</h2>
 			<filter-list
@@ -13,7 +13,7 @@
 	<script type="module">
 		let agentList = document.getElementById("agent-list");
 		if (agentList) {
-			agentList.items = {{ .agents }};
+			agentList.items = {{ $model.common.Agents }};
 
 			agentList.setSearchTextFunc((item) => {
 				return item.name;
@@ -31,7 +31,7 @@
 	</script>
 	{{ end }}
 
-	{{ if .places }}
+	{{ if $model.common.Places }}
 		<div>
 			<h2 class="mb-6">Erscheinungsorte</h2>
 			<filter-list
@@ -41,11 +41,11 @@
 		</div>
 	<script type="module">
 		let placeList = document.getElementById("place-list");
-		if (placeList) placeList.items = {{ .places }};
+		if (placeList) placeList.items = {{ $model.common.Places }};
 	</script>
 	{{ end }}
 
-	{{ if .years }}
+	{{ if $model.common.Years }}
 		<div>
 			<h2 class="mb-6">Geltungsjahre</h2>
 			<filter-list
@@ -57,7 +57,7 @@
 	<script type="module">
 		let yearList = document.getElementById("year-list");
 		if (yearList) {
-			yearList.items = {{ .years }};
+			yearList.items = {{ $model.common.Years }};
 
 			yearList.setHREFFunc((item) => {
 				return String(item);