@smartsoft001-mobilems/creators-shell-angular 0.0.0-stage → 2.122.0

package/fesm2022/smartsoft001-mobilems-creators-shell-angular.mjs

@@ -0,0 +1,2136 @@
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { inject, Injectable, signal, DestroyRef, computed, effect, untracked, Injector, PLATFORM_ID, viewChild, afterNextRender, Directive, input, output, linkedSignal } from '@angular/core';
+import { map, switchMap, of, forkJoin, catchError, throwError, shareReplay, Subject, distinctUntilChanged, combineLatest, startWith, scan, firstValueFrom } from 'rxjs';
+import { yearRangeValue, SharedConfig, decodeHtmlEntities, stripHtml, serializeCatalogFilter, yearRangeLabel, offsetToPage, createCatalog, MuseumSeoService, catalogListQueryParams, FileUrlService, catalogEntryFilterParams } from '@smartsoft001-mobilems/angular';
+import { SlugService, capitalize } from '@smartsoft001/utils';
+import { takeUntilDestroyed, toSignal, toObservable } from '@angular/core/rxjs-interop';
+import { Location, DOCUMENT, ViewportScroller, isPlatformBrowser } from '@angular/common';
+import { ActivatedRoute, Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+
+// prettier-ignore
+const CREATORS_ALPHABET = [
+    'A', 'Ą', 'B', 'C', 'Ć', 'D', 'E', 'Ę', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
+    'Ł', 'M', 'N', 'Ń', 'O', 'Ó', 'P', 'Q', 'R', 'S', 'Ś', 'T', 'U', 'V', 'W',
+    'X', 'Y', 'Z', 'Ź', 'Ż', '#',
+];
+/**
+ * `sw=` prefixes queried for the `#` bucket (the API has no "not a letter" filter).
+ *
+ * `"` and `„` are deliberately absent: the API treats them as a wildcard and
+ * returns every creator (all 8 pages). The foreign initials (`Č`, `Š`, `Ž`) are
+ * the ones present in the data today; `sw` is diacritic-sensitive, so a new one
+ * only needs to be appended here. Prefixes without matches answer 404 and give `[]`.
+ */
+// prettier-ignore
+const CREATORS_HASH_PREFIXES = [
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    '[', '(', "'", '-',
+    'Č', 'Š', 'Ž',
+];
+function isCreatorsLetter(value) {
+    return CREATORS_ALPHABET.includes(value);
+}
+/** Index letter of a name; anything outside the polish alphabet lands in `#`. */
+function creatorsLetterOf(name) {
+    const [first = ''] = Array.from(name.trim());
+    const upper = first.toLocaleUpperCase('pl');
+    return isCreatorsLetter(upper) ? upper : '#';
+}
+const CREATORS_POLISH_LETTERS = new Set(CREATORS_ALPHABET.slice(0, -1));
+/** Polish letters stay as they are; foreign diacritics fold to the base letter (é to e). */
+function creatorsFoldForeign(char) {
+    return CREATORS_POLISH_LETTERS.has(char.toLocaleUpperCase('pl'))
+        ? char
+        : char.normalize('NFD').replace(/\p{M}/gu, '');
+}
+/**
+ * Two-character group prefix ("Ab"); a single character when the second one is
+ * not a letter. A foreign second letter joins its base group ("Béraud" is "Be").
+ */
+function creatorsPrefixOf(name) {
+    const [first = '', second = ''] = Array.from(name.trim());
+    const head = first.toLocaleUpperCase('pl');
+    return /^\p{L}$/u.test(second)
+        ? head + creatorsFoldForeign(second).toLocaleLowerCase('pl')
+        : head;
+}
+const creatorsCollator = new Intl.Collator('pl', { sensitivity: 'base' });
+/** Creators grouped by `creatorsPrefixOf`, groups and items in polish alphabetical order. */
+function groupCreatorsByPrefix(items) {
+    const groups = new Map();
+    const nameOf = (item) => item.name ?? '';
+    const sorted = [...items].sort((a, b) => creatorsCollator.compare(nameOf(a), nameOf(b)));
+    for (const item of sorted) {
+        const prefix = creatorsPrefixOf(nameOf(item));
+        const group = groups.get(prefix);
+        if (group)
+            group.push(item);
+        else
+            groups.set(prefix, [item]);
+    }
+    return Array.from(groups, ([prefix, groupItems]) => ({
+        prefix,
+        items: groupItems,
+    })).sort((a, b) => creatorsCollator.compare(a.prefix, b.prefix));
+}
+/**
+ * API prefix (`GET dictionary/Creator/prefixes/{letter}` gives `AB`, `BÉ`, `A.`)
+ * in the form the index shows it: `Ab`.
+ */
+function creatorsDisplayPrefix(raw) {
+    const [head = '', ...rest] = Array.from(raw);
+    return head + rest.join('').toLocaleLowerCase('pl');
+}
+/**
+ * Index group of a creator, for links back to the index: the first two
+ * characters as the API lists them (`Ab`, `Bé`, `A.`), or the local `#` group.
+ */
+function creatorsIndexPrefixOf(name) {
+    const trimmed = name.trim();
+    if (creatorsLetterOf(trimmed) === '#')
+        return creatorsPrefixOf(trimmed);
+    return creatorsDisplayPrefix(Array.from(trimmed).slice(0, 2).join('').toLocaleUpperCase('pl'));
+}
+/**
+ * The prefix of `prefixes` the address names (`?prefiks=`, `#Ab`), case
+ * ignored. Diacritics count: the API keeps `Be` and `Bé` apart.
+ */
+function creatorsFindPrefix(raw, prefixes) {
+    if (!raw)
+        return null;
+    const upper = raw.toLocaleUpperCase('pl');
+    return (prefixes.find((prefix) => prefix.toLocaleUpperCase('pl') === upper) ?? null);
+}
+/** `?litera=` query param to index letter; invalid or missing falls back to `A`. */
+function parseCreatorsLetter(raw) {
+    const upper = (raw ?? '').toLocaleUpperCase('pl');
+    return isCreatorsLetter(upper) ? upper : 'A';
+}
+/**
+ * DOM id of a prefix group. Hex code points keep `[`, `'` etc. selector-safe.
+ * `base` is the museum's own anchor prefix (sztuki uses `artysci`).
+ */
+function creatorsPrefixAnchor(prefix, base = 'tworcy') {
+    const codePoints = Array.from(prefix, (char) => (char.codePointAt(0) ?? 0).toString(16));
+    return [base, ...codePoints].join('-');
+}
+/**
+ * `#fragment` from the address to where the index should go: a group anchor
+ * (as written), a group prefix (`#Ba`), or a letter (`#B`), which switches
+ * `?litera=` first and then lands on that letter's first group.
+ */
+function resolveCreatorsFragment(fragment, letter, groups) {
+    let raw = fragment;
+    try {
+        raw = decodeURIComponent(fragment);
+    }
+    catch {
+        // Malformed escape: match the fragment as written.
+    }
+    const byAnchor = groups.find((group) => group.anchor === raw);
+    if (byAnchor)
+        return { anchor: byAnchor.anchor };
+    const exact = creatorsFindPrefix(raw, groups.map((group) => group.prefix));
+    const byPrefix = groups.find((group) => group.prefix === exact) ??
+        groups.find((group) => creatorsCollator.compare(group.prefix, raw) === 0);
+    if (byPrefix)
+        return { anchor: byPrefix.anchor };
+    const upper = raw.toLocaleUpperCase('pl');
+    if (isCreatorsLetter(upper)) {
+        if (upper !== letter)
+            return { letter: upper };
+        return groups.length ? { anchor: groups[0].anchor } : null;
+    }
+    // A prefix of another letter (`#Cz` on A) or of the `#` bucket (`#1`,
+    // `#Ša`): switch letters first, then the prefix resolves.
+    const chars = Array.from(raw);
+    if (chars.length <= 2 && !/\s/u.test(raw)) {
+        const prefixLetter = creatorsLetterOf(raw);
+        if (prefixLetter !== letter)
+            return { letter: prefixLetter };
+    }
+    return null;
+}
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/;
+function creatorsUrlBirth(value, bound) {
+    const trimmed = value.trim();
+    return FULL_DATE.test(trimmed) ? trimmed : yearRangeValue(trimmed, bound);
+}
+/**
+ * List/search url of the Creator dictionary. An empty `q=` or `sw=` empties the list (404), so blank
+ * values are omitted. The birth range is the only working date filter and needs `YYYY-MM-DD`.
+ */
+function creatorsListUrl(apiUrl, query) {
+    let url = `${apiUrl}dictionary/Creator/search/page/${query.page ?? 1}?maxPerPage=${query.maxPerPage ?? 24}`;
+    if (query.extraData !== false)
+        url += '&extraData=true';
+    const q = query.q?.trim();
+    const sw = query.sw?.trim();
+    if (q)
+        url += `&q=${encodeURIComponent(q)}`;
+    const lastNameSw = query.lastNameSw?.trim();
+    if (sw)
+        url += `&sw=${encodeURIComponent(sw)}`;
+    if (lastNameSw)
+        url += `&lastNameSw=${encodeURIComponent(lastNameSw)}`;
+    if (query.sort)
+        url += `&sort=${query.sort}`;
+    if (query.birthFrom?.trim()) {
+        url += `&filter[dateFrom][from]=${creatorsUrlBirth(query.birthFrom, 'from')}`;
+    }
+    if (query.birthTo?.trim()) {
+        url += `&filter[dateFrom][to]=${creatorsUrlBirth(query.birthTo, 'to')}`;
+    }
+    return url;
+}
+/** Works (objects) of one creator; `authors[].id` of an object is the Creator id. */
+function creatorWorksUrl(apiUrl, id, page = 1, limit = 12) {
+    return `${apiUrl}search/Object/page/${page}?maxPerPage=${limit}&filter[creators][]=${encodeURIComponent(String(id))}`;
+}
+/** Two-letter groups of an index letter (lower-case, encoded), e.g. `prefixes/b`. */
+function creatorsPrefixesUrl(apiUrl, letter) {
+    return `${apiUrl}dictionary/Creator/prefixes/${encodeURIComponent(letter.toLocaleLowerCase('pl'))}`;
+}
+/** The creator profile (MOB-1972). Only some API hosts have it; the others answer 404. */
+function creatorProfileUrl(apiUrl, id) {
+    return `${apiUrl}creator/${encodeURIComponent(String(id))}`;
+}
+/** The Creator dictionary entry: every API host has it. */
+function creatorDictionaryUrl(apiUrl, id) {
+    return `${apiUrl}dictionary/Creator/${encodeURIComponent(String(id))}`;
+}
+/**
+ * First page of a related list of `creator/{id}` (`/api/search/Object/page/{page}?filter[…]`) with `maxPerPage`;
+ * `null` for a list without a path or results (no request needed).
+ */
+function creatorRelatedUrl(apiUrl, related, limit) {
+    if (!related?.path || !related.count)
+        return null;
+    const path = related.path.replace(/^\/?api\//, '').replace('{page}', '1');
+    const separator = path.includes('?') ? '&' : '?';
+    return `${apiUrl}${path}${separator}maxPerPage=${limit}`;
+}
+
+const CREATORS_ALL_PAGE_SIZE = 500;
+const creatorsServiceCollator = new Intl.Collator('pl', {
+    sensitivity: 'base',
+});
+class CreatorsService {
+    constructor() {
+        this.creatorsServiceHttp = inject(HttpClient);
+        this.creatorsServiceConfig = inject(SharedConfig);
+        /** The `#` bucket, loaded once per `apiUrl` for its prefixes and its groups. */
+        this.creatorsServiceHashCache = null;
+    }
+    getPage(query) {
+        return this.creatorsServiceGetRaw(query).pipe(map(({ data }) => ({
+            items: this.creatorsServiceNormalise(data?.items),
+            total: data?.paginatorDetails?.totalItemsCount ?? 0,
+            pages: data?.paginatorDetails?.totalPagesCount ?? 0,
+        })), this.creatorsServiceOnNotFound({
+            items: [],
+            total: 0,
+            pages: 0,
+        }));
+    }
+    /** Every page at `maxPerPage=500`, in page order. */
+    getAll(query = {}) {
+        const pageQuery = (page) => ({
+            ...query,
+            page,
+            maxPerPage: CREATORS_ALL_PAGE_SIZE,
+        });
+        return this.creatorsServiceGetRaw(pageQuery(1)).pipe(switchMap(({ data }) => {
+            const first = this.creatorsServiceNormalise(data?.items);
+            const total = data?.paginatorDetails?.totalPagesCount ?? 1;
+            const rest = Array.from({ length: Math.max(total - 1, 0) }, (_, i) => this.creatorsServiceGetRaw(pageQuery(i + 2)));
+            if (!rest.length)
+                return of(first);
+            return forkJoin(rest).pipe(map((pages) => first.concat(...pages.map((page) => this.creatorsServiceNormalise(page.data?.items)))));
+        }), this.creatorsServiceOnNotFound([]));
+    }
+    /**
+     * Creators on one index letter. `#` has no API filter, so it merges the
+     * `CREATORS_HASH_PREFIXES` searches (deduped by id). The result is re-checked with
+     * `creatorsLetterOf`, because `sw` also matches beyond the letter. `q` and the birth
+     * range go to every call.
+     */
+    getByLetter(letter, query) {
+        const items$ = letter === '#'
+            ? forkJoin(CREATORS_HASH_PREFIXES.map((prefix) => this.getAll({ ...query, sw: prefix }))).pipe(map((lists) => this.creatorsServiceUniqueById(lists.flat())))
+            : this.getAll({ ...query, sw: letter });
+        return items$.pipe(map((items) => items.filter((item) => creatorsLetterOf(item.name ?? '') === letter)));
+    }
+    /**
+     * Two-letter groups of an index letter (MOB-1959): the API lists them (`AB`,
+     * `BÉ`, `A.`), the index shows them as `Ab`. The `#` bucket has no API prefixes,
+     * so its groups come from the loaded entries. The prefixes endpoint and
+     * `lastNameSw` exist on the staging API; check the museum's API before use.
+     */
+    getPrefixes(letter) {
+        if (letter === '#') {
+            return this.creatorsServiceGetHashCreators().pipe(map((items) => groupCreatorsByPrefix(items).map((group) => group.prefix)));
+        }
+        return this.creatorsServiceHttp
+            .get(creatorsPrefixesUrl(this.creatorsServiceConfig.apiUrl, letter))
+            .pipe(map(({ data }) => [
+            ...new Set((data?.items ?? [])
+                .map(creatorsDisplayPrefix)
+                .filter((prefix) => creatorsLetterOf(prefix) === letter)),
+        ]), this.creatorsServiceOnNotFound([]));
+    }
+    /**
+     * Creators of one index group: every page of `lastNameSw`, in polish order.
+     * `#` filters its loaded entries.
+     */
+    getByIndexPrefix(letter, prefix) {
+        if (letter === '#') {
+            return this.creatorsServiceGetHashCreators().pipe(map((items) => items.filter((item) => creatorsPrefixOf(item.name ?? '') === prefix)));
+        }
+        return this.getAll({ lastNameSw: prefix, sort: 'default' }).pipe(map((items) => items
+            .filter((item) => creatorsLetterOf(item.name ?? '') === letter)
+            .sort((a, b) => creatorsServiceCollator.compare(a.name ?? '', b.name ?? ''))));
+    }
+    /**
+     * The creator profile `creator/{id}` (MOB-1972: life years, editorial biography, portrait, lead artwork, tags and
+     * related lists). An API host without it answers 404, so the dictionary entry `dictionary/Creator/{id}` is read
+     * then. `null` when both answer 404.
+     */
+    getById(id) {
+        const apiUrl = this.creatorsServiceConfig.apiUrl;
+        return this.creatorsServiceGetOne(creatorProfileUrl(apiUrl, id)).pipe(catchError((error) => error instanceof HttpErrorResponse && error.status === 404
+            ? this.creatorsServiceGetOne(creatorDictionaryUrl(apiUrl, id)).pipe(this.creatorsServiceOnNotFound(null))
+            : throwError(() => error)));
+    }
+    /** First works of a creator (`filter[creators][]`), `limit` per page; page 1 by default. */
+    getWorks(id, limit, page) {
+        return this.creatorsServiceGetObjects(creatorWorksUrl(this.creatorsServiceConfig.apiUrl, id, page, limit));
+    }
+    /** First page of a related list of `creator/{id}` (MOB-1963); no request for an empty one. */
+    getRelated(related, limit) {
+        const url = creatorRelatedUrl(this.creatorsServiceConfig.apiUrl, related, limit);
+        return url
+            ? this.creatorsServiceGetObjects(url)
+            : of({ items: [], total: 0 });
+    }
+    /**
+     * `getByLetter('#')` shared by the prefixes and the groups. It is kept per `apiUrl`
+     * (another API loads it again); a failure is not kept.
+     */
+    creatorsServiceGetHashCreators() {
+        const apiUrl = this.creatorsServiceConfig.apiUrl;
+        if (this.creatorsServiceHashCache?.apiUrl !== apiUrl) {
+            const cache = {
+                apiUrl,
+                items$: this.getByLetter('#').pipe(catchError((error) => {
+                    if (this.creatorsServiceHashCache === cache) {
+                        this.creatorsServiceHashCache = null;
+                    }
+                    return throwError(() => error);
+                }), shareReplay({ bufferSize: 1, refCount: false })),
+            };
+            this.creatorsServiceHashCache = cache;
+        }
+        return this.creatorsServiceHashCache.items$;
+    }
+    creatorsServiceGetOne(url) {
+        return this.creatorsServiceHttp
+            .get(url)
+            .pipe(map(({ data }) => data ? this.creatorsServiceNormaliseOne(data) : null));
+    }
+    creatorsServiceGetObjects(url) {
+        return this.creatorsServiceHttp
+            .get(url)
+            .pipe(map(({ data }) => ({
+            items: data?.items ?? [],
+            total: data?.paginatorDetails?.totalItemsCount ?? 0,
+        })), this.creatorsServiceOnNotFound({
+            items: [],
+            total: 0,
+        }));
+    }
+    creatorsServiceGetRaw(query) {
+        return this.creatorsServiceHttp.get(creatorsListUrl(this.creatorsServiceConfig.apiUrl, query));
+    }
+    creatorsServiceNormalise(items) {
+        return (items ?? []).map((item) => this.creatorsServiceNormaliseOne(item));
+    }
+    /** First occurrence wins: the `#` prefixes can return the same creator twice. */
+    creatorsServiceUniqueById(items) {
+        const seen = new Set();
+        return items.filter(({ id }) => !seen.has(id) && !!seen.add(id));
+    }
+    /** The API sends `id` as a JSON number in the list and the detail; the entity keys on a string. */
+    creatorsServiceNormaliseOne(item) {
+        return { ...item, id: String(item.id) };
+    }
+    /** The API answers 404 (`NO_RESULTS_FOR_GIVEN_QUERY`, `RECORD_NOT_FOUND`) for no data. */
+    creatorsServiceOnNotFound(fallback) {
+        return catchError((error) => error instanceof HttpErrorResponse && error.status === 404
+            ? of(fallback)
+            : throwError(() => error));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** Label of a dictionary value: an entry gives its name, text and numbers are shown as they are. */
+function creatorDictLabel(value) {
+    if (value === null || value === undefined)
+        return '';
+    return typeof value === 'object' ? (value.name ?? '') : String(value);
+}
+/**
+ * "Kobro, Katarzyna" gives "Katarzyna Kobro". Only with exactly one comma:
+ * other forms (groups, pseudonyms) stay as they are.
+ */
+function creatorDisplayName(name) {
+    const text = name ?? '';
+    const parts = text.split(',');
+    if (parts.length !== 2)
+        return text.trim();
+    const [surname, first] = parts.map((part) => part.trim());
+    return [first, surname].filter(Boolean).join(' ');
+}
+const CREATOR_YEAR = /\d{4}/g;
+/**
+ * Life years only: "1898.1.26 - 1951.2.26" gives "1898–1951". Without a period
+ * they come from `dateFrom`/`dateTo`. A period given as a dictionary id has no dates.
+ */
+function creatorLifeYears(item) {
+    const { period } = item;
+    const periodName = typeof period === 'string'
+        ? period
+        : typeof period === 'object' && period !== null
+            ? period.name
+            : undefined;
+    const source = periodName?.trim() || `${item.dateFrom ?? ''} ${item.dateTo ?? ''}`;
+    return source.match(CREATOR_YEAR)?.join('–');
+}
+/** A name from the CMS can be HTML with entities: plain text, spaces collapsed. */
+function creatorPlainName(name) {
+    return decodeHtmlEntities(stripHtml(name ?? ''))
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/** Ends of blocks and line breaks: words on both sides must stay apart once the tags go. */
+const CREATOR_BLOCK_BREAK = /<\/(?:p|div|li|h[1-6]|blockquote)>|<br\s*\/?>/gi;
+/** Comments, MSO conditional blocks (`<!--[if gte mso 9]>...<![endif]-->`) included. */
+const CREATOR_HTML_COMMENT = /<!--[\s\S]*?-->/g;
+/** A biography as one line of text. `MuseumSeoService` decodes entities and truncates. */
+function creatorPlainText(html) {
+    return stripHtml((html ?? '')
+        .replace(CREATOR_HTML_COMMENT, '')
+        .replace(CREATOR_BLOCK_BREAK, '$& '))
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Roles to show: `roleName`, else the name of a `role` object or a textual
+ * `role` string, then the additional roles. A numeric or id-like `role` (`366`,
+ * `'366'`) is never shown.
+ * Trimmed, empty ones dropped, deduped case-insensitively.
+ */
+function creatorRoles(creator) {
+    if (!creator)
+        return [];
+    const { role } = creator;
+    const roleName = typeof role === 'object' && role !== null
+        ? role.name
+        : typeof role === 'string' && !/^\d+$/.test(role.trim())
+            ? role
+            : undefined;
+    const names = [
+        creator.roleName?.trim() || roleName,
+        ...(creator.additionalRoles ?? []).map((entry) => entry?.name),
+    ];
+    const seen = new Set();
+    const result = [];
+    for (const name of names) {
+        const text = name?.trim();
+        const key = text?.toLocaleLowerCase('pl');
+        if (!text || !key || seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(text);
+    }
+    return result;
+}
+/** URL slug of the creator: the display name without markup. */
+function creatorSlug(creator) {
+    return SlugService.create(creatorDisplayName(creatorPlainName(creator.name)));
+}
+/** Router commands to the details page: `[path, id, slug]`, or `[path, id]` for an empty slug. */
+function creatorDetailsCommands(path, creator) {
+    const slug = creatorSlug(creator);
+    return slug ? [path, creator.id, slug] : [path, creator.id];
+}
+const CREATOR_DATE_YEAR = /^(\d{4})-\d{2}-\d{2}/;
+/**
+ * Years under the name (museum-artists `artistYears`, MOB-1972): "1898 – 1951". The years of the full dates
+ * (`birthDate`/`deathDate`) first, then the ready `lifeYears`, then `birthYear`/`deathYear`, then the years in the
+ * period; `''` without any.
+ */
+function creatorYears(creator) {
+    const born = CREATOR_DATE_YEAR.exec(creator.birthDate ?? '')?.[1];
+    const died = CREATOR_DATE_YEAR.exec(creator.deathDate ?? '')?.[1];
+    if (born || died)
+        return [born ?? '?', died ?? ''].join(' – ').trim();
+    const ready = creator.lifeYears?.trim();
+    if (ready)
+        return ready;
+    const bornYear = creator.birthYear ?? '';
+    const diedYear = creator.deathYear ?? '';
+    if (bornYear || diedYear) {
+        return [bornYear, diedYear].filter(Boolean).join(' – ');
+    }
+    const { period } = creator;
+    const text = typeof period === 'string'
+        ? period
+        : typeof period === 'object' && period !== null
+            ? (period.name ?? '')
+            : '';
+    return (text.match(CREATOR_YEAR) ?? []).slice(0, 2).join(' – ');
+}
+/** HTML whose text, without comments (MSO blocks), tags and entities (`&nbsp;`), is empty. */
+function creatorLooksEmpty(html) {
+    return !decodeHtmlEntities(stripHtml(html.replace(CREATOR_HTML_COMMENT, ''))).trim();
+}
+/**
+ * The biography html to show (museum-artists `artistBiography`): `editorialBiography`, then `biography`, then
+ * `description`, trimmed. A field that only looks filled (`<p>&nbsp;</p>`, Word's `<!--[if gte mso 9]>` blocks) is
+ * skipped; `''` without any.
+ */
+function creatorBiography(creator) {
+    if (!creator)
+        return '';
+    for (const html of [
+        creator.editorialBiography,
+        creator.biography,
+        creator.description,
+    ]) {
+        const value = html?.trim() ?? '';
+        if (value && !creatorLooksEmpty(value))
+            return value;
+    }
+    return '';
+}
+/** About six lines of the content column: a longer biography folds ("rozwiń tekst"). */
+const CREATOR_FOLD_CHARS = 600;
+function creatorBiographyText(html) {
+    return decodeHtmlEntities(creatorPlainText(html)).replace(/\s+/g, ' ').trim();
+}
+/** Whether the biography is longer than the folded view (600 characters of text). */
+function creatorIsLongBiography(html) {
+    return creatorBiographyText(html).length > CREATOR_FOLD_CHARS;
+}
+/** The start of the biography for the folded view: plain text, cut at a word, with an ellipsis. */
+function creatorBiographyExcerpt(html) {
+    const text = creatorBiographyText(html);
+    if (text.length <= CREATOR_FOLD_CHARS)
+        return text;
+    const cut = text.slice(0, CREATOR_FOLD_CHARS);
+    const space = cut.lastIndexOf(' ');
+    return `${(space > 0 ? cut.slice(0, space) : cut).replace(/[\s,.;:–-]+$/, '')}…`;
+}
+
+/**
+ * Group letter of a name: diacritics folded (NFD), only letters and digits
+ * kept, the first one upper-cased. `Ł` has no decomposition, so it stays its
+ * own letter. No letter or digit gives `#`.
+ */
+function creatorNfdLetter(name) {
+    const normalized = (name ?? '')
+        .normalize('NFD')
+        .replace(/\p{Diacritic}/gu, '')
+        .replace(/[^\p{L}\p{N}]/gu, '');
+    return normalized.charAt(0).toUpperCase() || '#';
+}
+const creatorsCompare = (a, b) => a.localeCompare(b, 'pl');
+/**
+ * Groups A-Z (reversed for `desc`), items A-Z inside a group either way. Both
+ * sorts use the Polish locale, so `Ł` follows `L` (Ossolineum's code-point sort
+ * puts it after `Z`).
+ */
+function groupCreatorsByLetter(items, desc = false) {
+    const groups = new Map();
+    for (const item of items) {
+        const letter = creatorNfdLetter(item.name);
+        const group = groups.get(letter);
+        if (group)
+            group.push(item);
+        else
+            groups.set(letter, [item]);
+    }
+    const result = Array.from(groups, ([letter, groupItems]) => ({
+        letter,
+        items: groupItems.sort((a, b) => creatorsCompare(a.name ?? '', b.name ?? '')),
+    })).sort((a, b) => creatorsCompare(a.letter, b.letter));
+    return desc ? result.reverse() : result;
+}
+
+const EMPTY_CREATORS_FILTER = {
+    phrase: '',
+    birthFrom: '',
+    birthTo: '',
+};
+const CREATORS_BIRTH_KEY = 'dateFrom';
+const CREATORS_YEAR = /^\d{1,4}$/;
+/** `?filter=` of the creators page: the phrase and the birth range as full dates. */
+function creatorsFilterQueryParams(value) {
+    const from = value.birthFrom.trim();
+    const to = value.birthTo.trim();
+    const query = [];
+    if (from) {
+        query.push({
+            key: CREATORS_BIRTH_KEY,
+            type: '>=',
+            value: yearRangeValue(from, 'from'),
+        });
+    }
+    if (to) {
+        query.push({
+            key: CREATORS_BIRTH_KEY,
+            type: '<=',
+            value: yearRangeValue(to, 'to'),
+        });
+    }
+    const filter = serializeCatalogFilter({
+        query: query,
+        searchText: value.phrase,
+    });
+    return filter ? { filter } : {};
+}
+/** Reads a parsed `?filter=` back into the form value. */
+function creatorsFilterValueOf(filter) {
+    const birth = (type) => {
+        const item = filter?.query?.find((entry) => entry.key === CREATORS_BIRTH_KEY && entry.type === type);
+        return item ? yearRangeLabel(item.value) : '';
+    };
+    return {
+        phrase: filter?.searchText?.trim() ?? '',
+        birthFrom: birth('>='),
+        birthTo: birth('<='),
+    };
+}
+function hasCreatorsFilter(value) {
+    return !!(value.phrase.trim() ||
+        value.birthFrom.trim() ||
+        value.birthTo.trim());
+}
+/** A birth year as the API takes it: 1-4 digits, from 1 to 9999. */
+function isCreatorsBirthYear(year) {
+    const trimmed = year.trim();
+    return CREATORS_YEAR.test(trimmed) && Number(trimmed) >= 1;
+}
+/** False for a year that is not `isCreatorsBirthYear`, or a range with `from` after `to`. */
+function isCreatorsBirthRangeValid(value) {
+    const from = value.birthFrom.trim();
+    const to = value.birthTo.trim();
+    if ((from && !isCreatorsBirthYear(from)) ||
+        (to && !isCreatorsBirthYear(to))) {
+        return false;
+    }
+    return !(from && to && Number(from) > Number(to));
+}
+
+/**
+ * List meta of a creators page, one format for the index and the filtered view of the same page:
+ * `capitalize(t(titleKey)) - capitalize(t(siteNameKey))`, `t(descriptionKey)`, `type: 'website'`
+ * and `url` only when it is set.
+ */
+function creatorsListSeoMetadata(seo, t) {
+    const metadata = {
+        title: `${capitalize(t(seo.titleKey))} - ${capitalize(t(seo.siteNameKey ?? 'MODEL.mainTitle'))}`,
+        description: t(seo.descriptionKey),
+        type: 'website',
+    };
+    if (seo.url)
+        metadata.url = seo.url;
+    return metadata;
+}
+
+/**
+ * The shown order of the last creators list (an index group or a catalog page). The details page
+ * reads prev/next from it; a deep link or SSR has no context and gets none.
+ */
+class CreatorsListContext {
+    constructor() {
+        this.creatorsListContextItems = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "creatorsListContextItems" }] : /* istanbul ignore next */ []));
+        this.items = this.creatorsListContextItems.asReadonly();
+    }
+    /** The shown order of a list; ids are stringified (the list API sends numbers). */
+    set(items) {
+        this.creatorsListContextItems.set(items.map((item) => ({ id: String(item.id), name: item.name ?? null })));
+    }
+    clear() {
+        this.creatorsListContextItems.set([]);
+    }
+    /** Prev/next of a creator, compared as strings; none for an id outside the list. */
+    neighbours(id) {
+        const items = this.creatorsListContextItems();
+        const index = id === null || id === undefined
+            ? -1
+            : items.findIndex((item) => item.id === String(id));
+        if (index < 0)
+            return { prev: null, next: null };
+        return {
+            prev: items[index - 1] ?? null,
+            next: items[index + 1] ?? null,
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsListContext, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsListContext, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsListContext, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** Page size 24, sorted by name A-Z, no letter and no filter. */
+const CREATORS_CATALOG_DEFAULTS = {
+    offset: 0,
+    limit: 24,
+    sortBy: 'name',
+    sortDesc: false,
+    query: [],
+};
+const CREATORS_CATALOG_LETTER_KEY = 'sw';
+const CREATORS_CATALOG_BIRTH_KEY = 'dateFrom';
+const CREATORS_CATALOG_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+/** Days of a month, February by the leap-year rule. */
+function creatorsCatalogDaysInMonth(year, month) {
+    if (month === 2) {
+        const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+        return leap ? 29 : 28;
+    }
+    return [4, 6, 9, 11].indexOf(month) >= 0 ? 30 : 31;
+}
+/**
+ * A birth bound as the API takes it (`YYYY-MM-DD`): an `isCreatorsBirthYear` year is widened with
+ * `yearRangeValue`, a full date must be a real calendar date whose year passes `isCreatorsBirthYear`. Anything else is `null` and is not sent:
+ * the API answers 400 `SEARCH_ERROR` to it.
+ */
+function creatorsCatalogBirthDate(value, bound) {
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return null;
+    const trimmed = String(value).trim();
+    const date = isCreatorsBirthYear(trimmed)
+        ? yearRangeValue(trimmed, bound)
+        : trimmed;
+    const match = CREATORS_CATALOG_DATE.exec(date);
+    if (!match)
+        return null;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const valid = isCreatorsBirthYear(match[1]) &&
+        month >= 1 &&
+        month <= 12 &&
+        day >= 1 &&
+        day <= creatorsCatalogDaysInMonth(year, month);
+    return valid ? date : null;
+}
+function creatorsCatalogQueryItem(filter, key, type = '=') {
+    return filter?.query?.find((item) => item.key === key && (item.type ?? '=') === type);
+}
+function creatorsCatalogLetter(filter) {
+    const value = creatorsCatalogQueryItem(filter, CREATORS_CATALOG_LETTER_KEY)?.value;
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+/**
+ * The catalog filter as a `CreatorsService.getPage` query: page and size, the phrase (`q`), the
+ * letter (query key `sw`), the birth range (query key `dateFrom`, `>=`/`<=`) and the name sort.
+ * A blank phrase or letter and an invalid birth bound are left out.
+ */
+function creatorsFilterToQuery(filter) {
+    const limit = filter?.limit || CREATORS_CATALOG_DEFAULTS.limit || 24;
+    const query = {
+        page: offsetToPage(filter?.offset ?? 0, limit),
+        maxPerPage: limit,
+        sort: filter?.sortBy === 'name'
+            ? filter.sortDesc
+                ? 'name-desc'
+                : 'name-asc'
+            : null,
+    };
+    const q = filter?.searchText?.trim();
+    const sw = creatorsCatalogLetter(filter);
+    const birthFrom = creatorsCatalogBirthDate(creatorsCatalogQueryItem(filter, CREATORS_CATALOG_BIRTH_KEY, '>=')?.value, 'from');
+    const birthTo = creatorsCatalogBirthDate(creatorsCatalogQueryItem(filter, CREATORS_CATALOG_BIRTH_KEY, '<=')?.value, 'to');
+    if (q)
+        query.q = q;
+    if (sw)
+        query.sw = sw;
+    if (birthFrom)
+        query.birthFrom = birthFrom;
+    if (birthTo)
+        query.birthTo = birthTo;
+    return query;
+}
+/**
+ * A signal facade over `CreatorsService.getPage` for `createCatalog` (not an NgRx CRUD slice).
+ * A newer read cancels the older one. Call in an injection context.
+ */
+function createCreatorsFacade() {
+    const service = inject(CreatorsService);
+    const filter = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "filter" }] : /* istanbul ignore next */ []));
+    const loading = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+    const error = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "error" }] : /* istanbul ignore next */ []));
+    const totalCount = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "totalCount" }] : /* istanbul ignore next */ []));
+    const list = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "list" }] : /* istanbul ignore next */ []));
+    const loadedFilter = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "loadedFilter" }] : /* istanbul ignore next */ []));
+    const reads = new Subject();
+    reads
+        .pipe(switchMap((next) => service.getPage(creatorsFilterToQuery(next)).pipe(map((page) => ({
+        page,
+        filter: next,
+    })), catchError((failure) => of({ error: failure })))), takeUntilDestroyed(inject(DestroyRef)))
+        .subscribe((result) => {
+        if ('page' in result) {
+            list.set(result.page.items);
+            loadedFilter.set(result.filter);
+            totalCount.set(result.page.total);
+            error.set(null);
+        }
+        else {
+            error.set(result.error);
+            list.set([]);
+            totalCount.set(0);
+        }
+        loading.set(false);
+    });
+    return {
+        filter: filter.asReadonly(),
+        loading: loading.asReadonly(),
+        error: error.asReadonly(),
+        totalCount: totalCount.asReadonly(),
+        list: list.asReadonly(),
+        loadedFilter: loadedFilter.asReadonly(),
+        read: (next) => {
+            filter.set(next);
+            loading.set(true);
+            reads.next(next);
+        },
+    };
+}
+/**
+ * The filtered creators list (`/artysci?filter=…`) on `createCatalog`, with the creators facade and
+ * no read guard (a foreign `CrudConfig` in the injector cannot stall it). After each load it writes
+ * the shown order into `CreatorsListContext`. Call in an injection context.
+ */
+function createCreatorsCatalog(options) {
+    const facade = createCreatorsFacade();
+    const listContext = inject(CreatorsListContext);
+    const catalog = createCatalog({
+        ...options,
+        defaults: options.defaults ?? CREATORS_CATALOG_DEFAULTS,
+        facade,
+        readGuard: false,
+    });
+    const sortDesc = computed(() => !!catalog.filter()?.sortDesc, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "sortDesc" }] : /* istanbul ignore next */ []));
+    // The shown page keeps the direction it was loaded with until the next one arrives.
+    const groups = computed(() => groupCreatorsByLetter(facade.list(), !!facade.loadedFilter()?.sortDesc), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "groups" }] : /* istanbul ignore next */ []));
+    effect(() => {
+        const shown = groups();
+        if (catalog.hasError()) {
+            untracked(() => listContext.clear());
+            return;
+        }
+        if (catalog.isLoading() || !catalog.filter())
+            return;
+        untracked(() => listContext.set(shown.flatMap((group) => group.items)));
+    });
+    const birthItem = (year, bound) => {
+        const value = year.trim()
+            ? creatorsCatalogBirthDate(year.trim(), bound)
+            : null;
+        return value
+            ? [
+                {
+                    key: CREATORS_CATALOG_BIRTH_KEY,
+                    value,
+                    type: bound === 'from' ? '>=' : '<=',
+                    hidden: true,
+                },
+            ]
+            : [];
+    };
+    const filterFor = (value) => {
+        const current = catalog.filter() ?? CREATORS_CATALOG_DEFAULTS;
+        const query = (current.query ?? []).filter((item) => !(item.key === CREATORS_CATALOG_BIRTH_KEY &&
+            (item.type === '>=' || item.type === '<=')));
+        return {
+            ...current,
+            offset: 0,
+            searchText: value.phrase.trim(),
+            query: [
+                ...query,
+                ...birthItem(value.birthFrom, 'from'),
+                ...birthItem(value.birthTo, 'to'),
+            ],
+        };
+    };
+    return {
+        ...catalog,
+        list: facade.list,
+        groups,
+        sortDesc,
+        startsWith: computed(() => creatorsCatalogLetter(catalog.filter())),
+        setStartsWith: (letter) => {
+            const trimmed = letter?.trim();
+            if (trimmed) {
+                catalog.setQueryItem(CREATORS_CATALOG_LETTER_KEY, trimmed);
+            }
+            else {
+                catalog.removeQueryKey(CREATORS_CATALOG_LETTER_KEY);
+            }
+        },
+        filterValue: computed(() => creatorsFilterValueOf(catalog.filter())),
+        filterFor,
+        applyFilter: (value) => {
+            const { searchText, query } = filterFor(value);
+            catalog.update({ searchText, query });
+        },
+    };
+}
+
+/** `?litera=` of the index. A constant: the letter stream is a field-initialized `toSignal`. */
+const CREATORS_INDEX_LETTER_PARAM = 'litera';
+/** `?prefiks=`: the two-letter group of the letter the index shows (MOB-1959). */
+const CREATORS_INDEX_PREFIX_PARAM = 'prefiks';
+/** `?filter=` belongs to the catalog results view; the index stays idle while it is there. */
+const CREATORS_INDEX_FILTER_PARAM = 'filter';
+const CREATORS_INDEX_LOADING = {
+    status: 'loading',
+    prefixes: [],
+    prefix: null,
+    items: [],
+};
+const CREATORS_INDEX_IDLE = {
+    status: 'success',
+    prefixes: [],
+    prefix: null,
+    items: [],
+};
+/**
+ * Logic of the creators letter index (museum-artists' `/artysci` at MOB-1959): `?litera=` picks the
+ * letter, `?prefiks=` its group, the address `#fragment` (`#B`, `#Ba`, an anchor) is followed once
+ * the group has loaded, and the mobile jump-to panel's choice is scrolled to and focused.
+ *
+ * The museum writes the HTML: a `#filtersButton` element (the focus goes back to it when the
+ * panel closes), a `[id]="group.anchor"` `tabindex="-1"` section for the shown group, and the
+ * jump-to panel bound to `changeLetter`, `selectPrefix` and `closeFilters`.
+ */
+class CreatorsIndexBaseComponent {
+    constructor() {
+        /** Anchor prefix of the groups (`tworcy-42-61`); sztuki uses `'artysci'`. Read lazily. */
+        this.creatorsIndexAnchorBase = 'tworcy';
+        /** SEO keys (Ossolineum's by default). Read once, after the subclass initialisers. */
+        this.creatorsIndexSeo = {
+            titleKey: 'creatorsPage',
+            descriptionKey: 'CREATORS.metaDescription',
+            siteNameKey: 'museumName',
+        };
+        this.creatorsIndexRoute = inject(ActivatedRoute);
+        this.creatorsIndexRouter = inject(Router);
+        this.creatorsIndexInjector = inject(Injector);
+        this.creatorsIndexLocation = inject(Location);
+        this.creatorsIndexDocument = inject(DOCUMENT);
+        this.creatorsIndexScroller = inject(ViewportScroller);
+        this.creatorsIndexIsBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+        this.creatorsIndexService = inject(CreatorsService);
+        this.creatorsIndexListContext = inject(CreatorsListContext);
+        this.creatorsIndexSeoService = inject(MuseumSeoService);
+        this.creatorsIndexTranslate = inject(TranslateService);
+        this.creatorsIndexRetry$ = new Subject();
+        /** Group picked in the jump-to panel, scrolled to once it has loaded. */
+        this.creatorsIndexPendingAnchor = signal(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "creatorsIndexPendingAnchor" }] : /* istanbul ignore next */ []));
+        /** Last `#fragment` already scrolled to, so data reloads do not jump again. */
+        this.creatorsIndexHandledFragment = null;
+        this.alphabet = CREATORS_ALPHABET;
+        this.creatorsIndexRouteState$ = this.creatorsIndexRoute.queryParamMap.pipe(map((params) => ({
+            letter: parseCreatorsLetter(params.get(CREATORS_INDEX_LETTER_PARAM)),
+            filtered: params.has(CREATORS_INDEX_FILTER_PARAM),
+        })), distinctUntilChanged((a, b) => a.letter === b.letter && a.filtered === b.filtered));
+        this.letter = toSignal(this.creatorsIndexRouteState$.pipe(map(({ letter }) => letter), distinctUntilChanged()), { initialValue: 'A' });
+        /**
+         * `?filter=` is present: the catalog results view owns the page and the index stays idle. The template switches
+         * between the index and the results view on it.
+         */
+        this.filtered = toSignal(this.creatorsIndexRouteState$.pipe(map(({ filtered }) => filtered)), { initialValue: false });
+        this.creatorsIndexPrefixParam$ = this.creatorsIndexRoute.queryParamMap.pipe(map((params) => params.get(CREATORS_INDEX_PREFIX_PARAM)), distinctUntilChanged());
+        this.creatorsIndexPrefixes$ = combineLatest([
+            this.creatorsIndexRouteState$,
+            this.creatorsIndexRetry$.pipe(startWith(undefined)),
+        ]).pipe(switchMap(([route]) => route.filtered
+            ? of({
+                ...route,
+                status: 'success',
+                prefixes: [],
+            })
+            : this.creatorsIndexService.getPrefixes(route.letter).pipe(map((prefixes) => ({ status: 'success', prefixes })), catchError(() => of({ status: 'error', prefixes: [] })), startWith({
+                status: 'loading',
+                prefixes: [],
+            }), map((state) => ({
+                ...route,
+                ...state,
+            })))), shareReplay({ bufferSize: 1, refCount: true }));
+        this.state = toSignal(combineLatest([
+            this.creatorsIndexPrefixes$,
+            this.creatorsIndexPrefixParam$,
+        ]).pipe(switchMap(([{ letter, filtered, status, prefixes }, raw]) => {
+            if (filtered)
+                return of(CREATORS_INDEX_IDLE);
+            return status === 'success'
+                ? this.creatorsIndexLoad(letter, prefixes, raw)
+                : of({ ...CREATORS_INDEX_LOADING, status });
+        })), { initialValue: CREATORS_INDEX_LOADING });
+        this.groups = computed(() => {
+            const { prefixes, prefix: shown, items } = this.state();
+            const base = this.creatorsIndexAnchorBase;
+            return prefixes.map((prefix) => ({
+                prefix,
+                anchor: creatorsPrefixAnchor(prefix, base),
+                items: prefix === shown ? items : [],
+            }));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "groups" }] : /* istanbul ignore next */ []));
+        this.prefixes = computed(() => this.state().prefixes, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "prefixes" }] : /* istanbul ignore next */ []));
+        this.activePrefix = computed(() => this.state().prefix, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activePrefix" }] : /* istanbul ignore next */ []));
+        this.activeAnchor = computed(() => {
+            const prefix = this.activePrefix();
+            return prefix
+                ? creatorsPrefixAnchor(prefix, this.creatorsIndexAnchorBase)
+                : null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activeAnchor" }] : /* istanbul ignore next */ []));
+        this.creatorsIndexFragment = toSignal(this.creatorsIndexRoute.fragment, { initialValue: null });
+        this.filtersOpen = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "filtersOpen" }] : /* istanbul ignore next */ []));
+        /** The museum's `#filtersButton` (template ref contract). */
+        this.creatorsIndexFiltersButton = viewChild('filtersButton', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "creatorsIndexFiltersButton" }] : /* istanbul ignore next */ []));
+        // Once, after the subclass initialisers, so an overridden `creatorsIndexSeo` counts.
+        effect(() => untracked(() => this.creatorsIndexApplySeo()));
+        // As the catalog: a failed load leaves no stale prev/next behind.
+        effect(() => {
+            const state = this.state();
+            if (this.filtered() || state.status === 'loading')
+                return;
+            if (state.status === 'error') {
+                untracked(() => this.creatorsIndexListContext.clear());
+                return;
+            }
+            const shown = this.groups().flatMap((group) => group.items);
+            untracked(() => this.creatorsIndexListContext.set(shown));
+        });
+        // The router's anchorScrolling fires on NavigationEnd, before the group's
+        // creators arrive, so an address like `/artysci#B` would never scroll.
+        effect(() => {
+            if (!this.creatorsIndexIsBrowser)
+                return;
+            if (this.filtered()) {
+                // The filter view owns the page; coming back to the same fragment scrolls again.
+                this.creatorsIndexHandledFragment = null;
+                return;
+            }
+            const fragment = this.creatorsIndexFragment();
+            const state = this.state();
+            if (!fragment) {
+                // Leaving the fragment (e.g. another letter) re-arms it for Back.
+                this.creatorsIndexHandledFragment = null;
+                return;
+            }
+            if (state.status === 'loading' && !state.prefixes.length)
+                return;
+            if (fragment === this.creatorsIndexHandledFragment)
+                return;
+            const groups = this.groups();
+            const target = resolveCreatorsFragment(fragment, this.letter(), groups);
+            if (!target)
+                return;
+            // A letter switch does not need this letter's list (it may have failed).
+            if ('letter' in target) {
+                this.creatorsIndexRouter.navigate([], {
+                    relativeTo: this.creatorsIndexRoute,
+                    queryParams: { [CREATORS_INDEX_LETTER_PARAM]: target.letter },
+                    fragment,
+                    replaceUrl: true,
+                });
+                return;
+            }
+            // Another group of this letter is loaded first (`?prefiks=`).
+            const group = groups.find((g) => g.anchor === target.anchor);
+            if (group && group.prefix !== state.prefix) {
+                this.creatorsIndexRouter.navigate([], {
+                    relativeTo: this.creatorsIndexRoute,
+                    queryParams: {
+                        [CREATORS_INDEX_LETTER_PARAM]: this.letter(),
+                        [CREATORS_INDEX_PREFIX_PARAM]: group.prefix,
+                    },
+                    fragment,
+                    replaceUrl: true,
+                });
+                return;
+            }
+            if (state.status !== 'success')
+                return;
+            this.creatorsIndexHandledFragment = fragment;
+            afterNextRender(() => this.jumpTo(target.anchor), {
+                injector: this.creatorsIndexInjector,
+            });
+        });
+        // The group picked in the jump-to panel is reached once it has loaded; when
+        // it fails, the focus goes back to the filters button instead.
+        effect(() => {
+            const state = this.state();
+            const anchor = this.creatorsIndexPendingAnchor();
+            if (!anchor || this.filtersOpen() || state.status === 'loading')
+                return;
+            if (anchor !== this.activeAnchor())
+                return;
+            this.creatorsIndexPendingAnchor.set(null);
+            afterNextRender(() => state.status === 'success'
+                ? this.jumpTo(anchor)
+                : this.creatorsIndexFocusFiltersButton(), { injector: this.creatorsIndexInjector });
+        });
+    }
+    back() {
+        this.creatorsIndexLocation.back();
+    }
+    /** Scrolls to a group and moves focus to it (the router only scrolls). Browser only. */
+    jumpTo(anchor) {
+        if (!this.creatorsIndexIsBrowser)
+            return;
+        this.creatorsIndexScroller.scrollToAnchor(anchor);
+        this.creatorsIndexDocument
+            .getElementById(anchor)
+            ?.focus({ preventScroll: true });
+    }
+    openFilters() {
+        this.creatorsIndexPendingAnchor.set(null);
+        this.filtersOpen.set(true);
+    }
+    changeLetter(letter) {
+        this.creatorsIndexPendingAnchor.set(null);
+        this.creatorsIndexRouter.navigate([], {
+            relativeTo: this.creatorsIndexRoute,
+            queryParams: { [CREATORS_INDEX_LETTER_PARAM]: letter },
+        });
+    }
+    /** The panel's group: loaded through `?prefiks=`, then scrolled to. */
+    selectPrefix(prefix) {
+        const anchor = creatorsPrefixAnchor(prefix, this.creatorsIndexAnchorBase);
+        this.creatorsIndexPendingAnchor.set(anchor);
+        this.creatorsIndexRouter
+            .navigate([], {
+            relativeTo: this.creatorsIndexRoute,
+            queryParams: {
+                [CREATORS_INDEX_LETTER_PARAM]: this.letter(),
+                [CREATORS_INDEX_PREFIX_PARAM]: prefix,
+            },
+        })
+            .then((navigated) => {
+            // A cancelled navigation never loads the group; the same address
+            // (the active group applied again) is reached by the effect.
+            if (navigated || this.creatorsIndexPendingAnchor() !== anchor)
+                return;
+            if (anchor === this.activeAnchor())
+                return;
+            this.creatorsIndexPendingAnchor.set(null);
+            this.creatorsIndexFocusFiltersButton();
+        });
+    }
+    /**
+     * Focus moves after the next render, once the panel is gone: to the picked group once it has
+     * loaded, or back to the filters button (Safari does not focus a button on click).
+     */
+    closeFilters() {
+        this.filtersOpen.set(false);
+        if (this.creatorsIndexPendingAnchor())
+            return;
+        afterNextRender(() => this.creatorsIndexFocusFiltersButton(), {
+            injector: this.creatorsIndexInjector,
+        });
+    }
+    retry() {
+        this.creatorsIndexRetry$.next();
+    }
+    creatorsIndexFocusFiltersButton() {
+        if (!this.creatorsIndexIsBrowser)
+            return;
+        this.creatorsIndexFiltersButton()?.nativeElement.focus();
+    }
+    creatorsIndexApplySeo() {
+        this.creatorsIndexSeoService.apply(creatorsListSeoMetadata(this.creatorsIndexSeo, (key) => String(this.creatorsIndexTranslate.instant(key) ?? '')));
+    }
+    creatorsIndexLoad(letter, prefixes, raw) {
+        const prefix = creatorsFindPrefix(raw, prefixes) ?? prefixes[0] ?? null;
+        const base = { prefixes, prefix };
+        if (!prefix)
+            return of({ ...base, status: 'success', items: [] });
+        return this.creatorsIndexService.getByIndexPrefix(letter, prefix).pipe(map((items) => ({
+            ...base,
+            status: 'success',
+            items,
+        })), catchError(() => of({ ...base, status: 'error', items: [] })), startWith({ ...base, status: 'loading', items: [] }));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsIndexBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "22.1.3", type: CreatorsIndexBaseComponent, isStandalone: true, viewQueries: [{ propertyName: "creatorsIndexFiltersButton", first: true, predicate: ["filtersButton"], descendants: true, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsIndexBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [], propDecorators: { creatorsIndexFiltersButton: [{ type: i0.ViewChild, args: ['filtersButton', { isSignal: true }] }] } });
+
+/**
+ * Logic of the mobile "go to" panel of the creators index (museum-artists'
+ * `index-filters-mobile`, MOB-1949/1959). The choice is a draft until `apply()`:
+ * another letter emits `letterChange`, a prefix of the current letter emits
+ * `prefixSelect`. Every way out (close, backdrop, Escape, apply) emits `closed`;
+ * the host removes the panel and moves the focus on.
+ *
+ * Escape is bound here (`host`), so a subclass must not bind it again.
+ */
+class CreatorsJumpToBaseComponent {
+    constructor() {
+        /**
+         * The header the card opens under; the first element found wins. Read after the
+         * first render, so an override counts.
+         */
+        this.creatorsJumpToHeaderSelectors = [
+            'app-header',
+            'app-nav-bar',
+        ];
+        this.creatorsJumpToDocument = inject(DOCUMENT);
+        this.letters = input.required(/* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "letters" }] : /* istanbul ignore next */ []));
+        this.activeLetter = input.required(/* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activeLetter" }] : /* istanbul ignore next */ []));
+        /** Prefix groups of the loaded (active) letter. */
+        this.prefixes = input([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "prefixes" }] : /* istanbul ignore next */ []));
+        /** Prefix the index currently shows, pre-selected. */
+        this.activePrefix = input(null, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activePrefix" }] : /* istanbul ignore next */ []));
+        this.letterChange = output();
+        this.prefixSelect = output();
+        this.closed = output();
+        this.selectedLetter = linkedSignal(() => this.activeLetter(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedLetter" }] : /* istanbul ignore next */ []));
+        this.selectedPrefix = linkedSignal(() => this.activePrefix(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedPrefix" }] : /* istanbul ignore next */ []));
+        /** The card's top edge: the header's bottom edge, measured once the panel is rendered. */
+        this.topOffset = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "topOffset" }] : /* istanbul ignore next */ []));
+        afterNextRender(() => this.topOffset.set(this.creatorsJumpToMeasureHeader()));
+    }
+    selectLetter(letter) {
+        this.selectedLetter.set(letter);
+        this.selectedPrefix.set(null);
+    }
+    apply() {
+        const letter = this.selectedLetter();
+        const prefix = this.selectedPrefix();
+        if (letter !== this.activeLetter())
+            this.letterChange.emit(letter);
+        else if (prefix)
+            this.prefixSelect.emit(prefix);
+        this.closed.emit();
+    }
+    close() {
+        this.closed.emit();
+    }
+    creatorsJumpToMeasureHeader() {
+        let header = null;
+        for (const selector of this.creatorsJumpToHeaderSelectors) {
+            header = this.creatorsJumpToDocument.querySelector(selector);
+            if (header)
+                break;
+        }
+        return Math.max(0, Math.round(header?.getBoundingClientRect().bottom ?? 0));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsJumpToBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: CreatorsJumpToBaseComponent, isStandalone: true, inputs: { letters: { classPropertyName: "letters", publicName: "letters", isSignal: true, isRequired: true, transformFunction: null }, activeLetter: { classPropertyName: "activeLetter", publicName: "activeLetter", isSignal: true, isRequired: true, transformFunction: null }, prefixes: { classPropertyName: "prefixes", publicName: "prefixes", isSignal: true, isRequired: false, transformFunction: null }, activePrefix: { classPropertyName: "activePrefix", publicName: "activePrefix", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { letterChange: "letterChange", prefixSelect: "prefixSelect", closed: "closed" }, host: { listeners: { "keydown.escape": "close()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsJumpToBaseComponent, decorators: [{
+            type: Directive,
+            args: [{ host: { '(keydown.escape)': 'close()' } }]
+        }], ctorParameters: () => [], propDecorators: { letters: [{ type: i0.Input, args: [{ isSignal: true, alias: "letters", required: true }] }], activeLetter: [{ type: i0.Input, args: [{ isSignal: true, alias: "activeLetter", required: true }] }], prefixes: [{ type: i0.Input, args: [{ isSignal: true, alias: "prefixes", required: false }] }], activePrefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "activePrefix", required: false }] }], letterChange: [{ type: i0.Output, args: ["letterChange"] }], prefixSelect: [{ type: i0.Output, args: ["prefixSelect"] }], closed: [{ type: i0.Output, args: ["closed"] }] } });
+
+/**
+ * Base of the filtered creators list (`/artysci?filter=…`) on `createCreatorsCatalog`: first read,
+ * persistence, sort/size/page, the letter, the phrase and the birth range come from `catalog`;
+ * the page keeps its template. The url is the source of truth for the filter: `applyFilter` navigates
+ * to `?filter=` (the catalog reads it), `clearAllFilters` goes back to the index (`listPath`).
+ *
+ * ```ts
+ * export class ResultsComponent extends CreatorsCatalogBaseComponent {
+ *   constructor() {
+ *     super({ persistKey: 'ARTISTS', listPath: '/artysci', seo: { titleKey: 'PAGE_TITLES.artists', descriptionKey: 'ARTISTS.metaDescription' } });
+ *   }
+ * }
+ * ```
+ *
+ * A `#listContainer` element in the template is scrolled to after a page change from the bottom
+ * pagination (`bottomPageChange`), in the browser only.
+ */
+class CreatorsCatalogBaseComponent {
+    constructor(options) {
+        this.creatorsCatalogPageTranslate = inject(TranslateService);
+        this.creatorsCatalogPageRouter = inject(Router);
+        this.creatorsCatalogPageSeoService = inject(MuseumSeoService);
+        this.creatorsCatalogPageIsBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+        this.creatorsCatalogPageListContainer = viewChild('listContainer', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "creatorsCatalogPageListContainer" }] : /* istanbul ignore next */ []));
+        this.creatorsCatalogPageScrollAfterLoad = false;
+        /** The phrase or a birth bound is set. */
+        this.hasActiveFilters = computed(() => hasCreatorsFilter(this.catalog.filterValue()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasActiveFilters" }] : /* istanbul ignore next */ []));
+        const { seo, ...catalogOptions } = options;
+        this.catalog = createCreatorsCatalog(catalogOptions);
+        this.creatorsCatalogPageListPath = options.listPath;
+        // After a page change from the bottom pagination scroll to the list top
+        // once the data has loaded.
+        effect(() => {
+            const loading = this.catalog.isLoading();
+            if (loading ||
+                !this.creatorsCatalogPageScrollAfterLoad ||
+                !this.creatorsCatalogPageIsBrowser) {
+                return;
+            }
+            this.creatorsCatalogPageScrollAfterLoad = false;
+            setTimeout(() => this.creatorsCatalogPageListContainer()?.nativeElement.scrollIntoView({
+                behavior: 'smooth',
+                block: 'start',
+            }));
+        });
+        if (seo)
+            this.creatorsCatalogPageApplySeo(seo);
+    }
+    pageChange(page) {
+        this.catalog.setPage(page);
+    }
+    bottomPageChange(page) {
+        this.creatorsCatalogPageScrollAfterLoad = true;
+        this.pageChange(page);
+    }
+    onLimitChange(limit) {
+        this.catalog.setLimit(limit);
+    }
+    sortChange(key) {
+        this.catalog.setSortKey(key);
+    }
+    onSearch(phrase) {
+        this.catalog.search(phrase);
+    }
+    /** The letter (`sw`); `null` or blank drops it. */
+    setStartsWith(letter) {
+        this.catalog.setStartsWith(letter);
+    }
+    /**
+     * Navigates to `listPath?filter=…` with the phrase and the birth range (the letter, the sort and the size kept);
+     * the catalog reads the new `?filter=`. Without any filter the url has no `?filter=`, so the index shows.
+     */
+    applyFilter(value) {
+        void this.creatorsCatalogPageRouter.navigate([this.creatorsCatalogPageListPath], { queryParams: catalogListQueryParams(this.catalog.filterFor(value)) });
+    }
+    retryLoad() {
+        this.catalog.retry();
+    }
+    /** Back to the index: `listPath` without parameters. */
+    clearAllFilters() {
+        void this.creatorsCatalogPageRouter.navigate([
+            this.creatorsCatalogPageListPath,
+        ]);
+    }
+    /**
+     * The index's list meta (`creatorsListSeoMetadata`), not in a search tab: the canonical url of
+     * the list must not point at a phrase url.
+     */
+    creatorsCatalogPageApplySeo(seo) {
+        if (this.catalog.searchEnabled())
+            return;
+        this.creatorsCatalogPageSeoService.apply(creatorsListSeoMetadata(seo, (key) => String(this.creatorsCatalogPageTranslate.instant(key) ?? '')));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsCatalogBaseComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "22.1.3", type: CreatorsCatalogBaseComponent, isStandalone: true, viewQueries: [{ propertyName: "creatorsCatalogPageListContainer", first: true, predicate: ["listContainer"], descendants: true, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsCatalogBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: undefined }], propDecorators: { creatorsCatalogPageListContainer: [{ type: i0.ViewChild, args: ['listContainer', { isSignal: true }] }] } });
+
+/**
+ * Logic of the creators filters modal: a draft of the phrase and the birth range, started from
+ * `value` (and again on each new `value`), applied with `apply()`. Escape closes it (bound by the
+ * base; a subclass must not bind it again). The museum writes the HTML.
+ */
+class CreatorsFiltersBaseComponent {
+    constructor() {
+        /** The applied filter (`catalog.filterValue()`). */
+        this.value = input(EMPTY_CREATORS_FILTER, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+        this.phrase = linkedSignal(() => this.value().phrase, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "phrase" }] : /* istanbul ignore next */ []));
+        this.birthFrom = linkedSignal(() => this.value().birthFrom, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "birthFrom" }] : /* istanbul ignore next */ []));
+        this.birthTo = linkedSignal(() => this.value().birthTo, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "birthTo" }] : /* istanbul ignore next */ []));
+        /** A year that the API does not take, or `from` after `to`. */
+        this.rangeInvalid = computed(() => !isCreatorsBirthRangeValid(this.creatorsFiltersDraft()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "rangeInvalid" }] : /* istanbul ignore next */ []));
+        this.applied = output();
+        this.closed = output();
+    }
+    /** Emits the trimmed draft, then `closed`; nothing while `rangeInvalid`. */
+    apply() {
+        if (this.rangeInvalid())
+            return;
+        this.applied.emit(this.creatorsFiltersDraft());
+        this.closed.emit();
+    }
+    /** Clears the draft; the applied filter stays until `apply()`. */
+    reset() {
+        this.phrase.set('');
+        this.birthFrom.set('');
+        this.birthTo.set('');
+    }
+    close() {
+        this.closed.emit();
+    }
+    creatorsFiltersDraft() {
+        return {
+            phrase: this.phrase().trim(),
+            birthFrom: this.birthFrom().trim(),
+            birthTo: this.birthTo().trim(),
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsFiltersBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: CreatorsFiltersBaseComponent, isStandalone: true, inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { applied: "applied", closed: "closed" }, host: { listeners: { "keydown.escape": "close()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsFiltersBaseComponent, decorators: [{
+            type: Directive,
+            args: [{ host: { '(keydown.escape)': 'close()' } }]
+        }], propDecorators: { value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }], applied: [{ type: i0.Output, args: ["applied"] }], closed: [{ type: i0.Output, args: ["closed"] }] } });
+
+/**
+ * Logic of a creator list card: display name, life years, roles, image with the placeholder and
+ * the details link. The museum writes the HTML.
+ */
+class CreatorCardBaseComponent {
+    constructor() {
+        /** Details path (`/tworcy/:id/:slug`); sztuki uses `'/artysci'`. Read lazily. */
+        this.creatorCardPath = '/tworcy';
+        /** Image when the creator has none. Read lazily. */
+        this.creatorCardPlaceholder = '/gfx/no-image.png';
+        this.creatorCardFileUrl = inject(FileUrlService);
+        this.item = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "item" }] : /* istanbul ignore next */ []));
+        /** "Kobro, Katarzyna" gives "Katarzyna Kobro" (markup dropped). */
+        this.displayName = computed(() => creatorDisplayName(creatorPlainName(this.item()?.name)), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "displayName" }] : /* istanbul ignore next */ []));
+        /** "1898–1951"; `''` without an item or years. */
+        this.lifeYears = computed(() => {
+            const item = this.item();
+            return (item && creatorLifeYears(item)) || '';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "lifeYears" }] : /* istanbul ignore next */ []));
+        /** Roles, comma separated. */
+        this.roles = computed(() => creatorRoles(this.item()).join(', '), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "roles" }] : /* istanbul ignore next */ []));
+        /** A string `image` as is, an `MsFile` through `FileUrlService`, else `extraData.image`, else the placeholder. */
+        this.imageSrc = computed(() => {
+            const item = this.item();
+            if (!item)
+                return '';
+            const placeholder = this.creatorCardPlaceholder;
+            const { image } = item;
+            if (typeof image === 'string' && image.trim())
+                return image;
+            if (image && typeof image === 'object') {
+                return this.creatorCardFileUrl.get(image, 'cache', placeholder);
+            }
+            return item.extraData?.image?.trim() || placeholder;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "imageSrc" }] : /* istanbul ignore next */ []));
+        /** Router commands to the details page; `[]` without an item. */
+        this.link = computed(() => {
+            const item = this.item();
+            return item ? creatorDetailsCommands(this.creatorCardPath, item) : [];
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "link" }] : /* istanbul ignore next */ []));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorCardBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: CreatorCardBaseComponent, isStandalone: true, inputs: { item: { classPropertyName: "item", publicName: "item", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorCardBaseComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { item: [{ type: i0.Input, args: [{ isSignal: true, alias: "item", required: false }] }] } });
+
+/** Four rows of three, like the works category view. */
+const CREATORS_SEARCH_LIMIT = 12;
+const CREATORS_SEARCH_PAGE_SIZES = [12, 24, 48];
+const CREATORS_SEARCH_LOADING = {
+    status: 'loading',
+    items: [],
+    total: 0,
+};
+/**
+ * Logic of the "creators" category of the site search (`/wyszukaj/:text/artysci`): the phrase of
+ * the route, the page and the page size, the loaded page and the list context. The view (layout,
+ * toolbar, cards, pagination) stays in the museum.
+ *
+ * The request depends on the phrase, the page and the limit only. A `#results` template ref is
+ * scrolled to after a page change from the bottom pagination (`changePage(page, true)`), in the
+ * browser only.
+ */
+class CreatorsSearchListBaseComponent {
+    constructor() {
+        this.creatorsSearchListRoute = inject(ActivatedRoute);
+        this.creatorsSearchListService = inject(CreatorsService);
+        this.creatorsSearchListContext = inject(CreatorsListContext);
+        this.creatorsSearchListIsBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+        this.creatorsSearchListResults = viewChild('results', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "creatorsSearchListResults" }] : /* istanbul ignore next */ []));
+        this.creatorsSearchListRetry$ = new Subject();
+        this.creatorsSearchListScrollAfterLoad = false;
+        this.pageSizes = [...CREATORS_SEARCH_PAGE_SIZES];
+        /**
+         * The phrase from `wyszukaj/:text`. The category route is lazy and has no component, so `:text`
+         * is not on `route.parent`: the params of the whole path are merged.
+         */
+        this.text = toSignal(combineLatest(this.creatorsSearchListRoute.pathFromRoot.map((route) => route.params)).pipe(map((all) => {
+            const params = Object.assign({}, ...all);
+            return String(params['text'] ?? '');
+        }), distinctUntilChanged()), { requireSync: true });
+        this.limit = signal(CREATORS_SEARCH_LIMIT, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "limit" }] : /* istanbul ignore next */ []));
+        /** 1-based; a new phrase or page size goes back to the first page. */
+        this.page = linkedSignal({ ...(ngDevMode ? { debugName: "page" } : /* istanbul ignore next */ {}), source: () => ({ text: this.text(), limit: this.limit() }),
+            computation: () => 1 });
+        this.creatorsSearchListRequest = computed(() => ({
+            text: this.text(),
+            page: this.page(),
+            limit: this.limit(),
+        }), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "creatorsSearchListRequest" }] : /* istanbul ignore next */ []));
+        this.state = toSignal(combineLatest([
+            toObservable(this.creatorsSearchListRequest),
+            this.creatorsSearchListRetry$.pipe(startWith(undefined)),
+        ]).pipe(switchMap(([request]) => this.creatorsSearchListLoad(request)), 
+        // The total stays while the next page loads, so the pagination does not vanish.
+        scan((previous, next) => next.status === 'loading' ? { ...next, total: previous.total } : next, CREATORS_SEARCH_LOADING)), { initialValue: CREATORS_SEARCH_LOADING });
+        this.totalCount = computed(() => this.state().total, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "totalCount" }] : /* istanbul ignore next */ []));
+        this.items = computed(() => this.state().items, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "items" }] : /* istanbul ignore next */ []));
+        // The details page reads prev/next from the shown results; a failed load clears them, as the catalog does.
+        effect(() => {
+            const state = this.state();
+            if (state.status === 'success') {
+                this.creatorsSearchListContext.set(state.items);
+            }
+            else if (state.status === 'error') {
+                this.creatorsSearchListContext.clear();
+            }
+        });
+        // After a page change from the bottom pagination scroll to the list top once it has loaded.
+        effect(() => {
+            if (this.state().status === 'loading' ||
+                !this.creatorsSearchListScrollAfterLoad ||
+                !this.creatorsSearchListIsBrowser) {
+                return;
+            }
+            this.creatorsSearchListScrollAfterLoad = false;
+            setTimeout(() => this.creatorsSearchListResults()?.nativeElement.scrollIntoView({
+                behavior: 'smooth',
+                block: 'start',
+            }));
+        });
+    }
+    /** `scrollToResults`: the change came from the bottom pagination, below the list. */
+    changePage(page, scrollToResults = false) {
+        this.creatorsSearchListScrollAfterLoad = scrollToResults;
+        this.page.set(page);
+    }
+    changeLimit(limit) {
+        this.limit.set(limit);
+    }
+    retry() {
+        this.creatorsSearchListRetry$.next();
+    }
+    creatorsSearchListLoad({ text, page, limit, }) {
+        return this.creatorsSearchListService
+            .getPage({ q: text, page, maxPerPage: limit, extraData: true })
+            .pipe(map(({ items, total }) => ({
+            status: 'success',
+            items,
+            total,
+        })), catchError(() => of({
+            ...CREATORS_SEARCH_LOADING,
+            status: 'error',
+        })), startWith(CREATORS_SEARCH_LOADING));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsSearchListBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "22.1.3", type: CreatorsSearchListBaseComponent, isStandalone: true, viewQueries: [{ propertyName: "creatorsSearchListResults", first: true, predicate: ["results"], descendants: true, isSignal: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorsSearchListBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [], propDecorators: { creatorsSearchListResults: [{ type: i0.ViewChild, args: ['results', { isSignal: true }] }] } });
+
+/** Ossolineum's keys for the rows and the title; museum-artists' for the contents and the share (Ossolineum has neither). */
+const CREATOR_DETAILS_KEYS = {
+    period: 'DETAILS_PAGE.activityPeriod',
+    birth: 'DETAILS_PAGE.placeDateOfBirth',
+    death: 'DETAILS_PAGE.placeDateOfDeath',
+    sectionKey: 'creatorsPage',
+    siteNameKey: 'museumName',
+    notFoundKey: 'NOT_FOUND.title',
+    biographyToc: 'ARTISTS.toc.description',
+    shareCopied: 'ARTISTS.shareCopied',
+};
+/** museum-artists' strips (MOB-1963), in the order of the UX board. */
+const CREATOR_RELATED_STRIPS = [
+    {
+        key: 'works',
+        anchor: 'dziela',
+        labelKey: 'ARTISTS.related.works',
+        pageSize: 6,
+        limit: 18,
+    },
+    {
+        key: 'exhibitions',
+        anchor: 'wystawy',
+        labelKey: 'ARTISTS.related.exhibitions',
+        pageSize: 3,
+        limit: 9,
+    },
+    {
+        key: 'archives',
+        anchor: 'archiwum',
+        labelKey: 'ARTISTS.related.archives',
+        pageSize: 3,
+        limit: 9,
+    },
+    {
+        key: 'msBooks',
+        anchor: 'ksiazki-ms',
+        labelKey: 'ARTISTS.related.msBooks',
+        pageSize: 3,
+        limit: 9,
+    },
+];
+const CREATOR_DETAILS_LOADING = {
+    status: 'loading',
+    creator: null,
+};
+const CREATOR_DETAILS_NOT_FOUND = {
+    status: 'not-found',
+    creator: null,
+};
+const CREATOR_DETAILS_NO_RELATED = {
+    loading: false,
+    lists: {},
+};
+const CREATOR_DETAILS_NO_OBJECTS = { items: [], total: 0 };
+const CREATOR_DETAILS_HTTP_URL = /^https?:\/\//i;
+const CREATOR_DETAILS_NUMERIC_ID = /^\d+$/;
+/** How long the address fragment keeps its position while the layout above it changes. */
+const CREATOR_DETAILS_FRAGMENT_SETTLE_MS = 2000;
+const CREATOR_DETAILS_USER_SCROLL_EVENTS = [
+    'wheel',
+    'touchstart',
+    'keydown',
+    'mousedown',
+];
+/**
+ * Logic of a creator details page (museum-artists' `ItemComponent`, MOB-1972/1963, and Ossolineum's sections): the
+ * creator of the `:id` param (`creator/{id}`, else the dictionary entry), its detail rows, years, biography (folded
+ * when long), portrait, lead artwork, tags, activity places, bibliography, authority links, gallery, the related
+ * strips (works, exhibitions, archives, MS books) and the contents, prev/next from `CreatorsListContext`, the way back
+ * to the index, share, the scroll to the address fragment and the SEO (also during SSR, via
+ * `MuseumSeoService.applyForSsr`). The museum writes the HTML.
+ */
+class CreatorDetailsBaseComponent {
+    constructor() {
+        /** Details path (`/tworcy/:id/:slug`); sztuki uses `'/artysci'`. Starts with `/`. Read lazily. */
+        this.creatorDetailsPath = '/tworcy';
+        /** Row labels, SEO title keys and the page texts. Read lazily. */
+        this.creatorDetailsKeys = CREATOR_DETAILS_KEYS;
+        /** The related strips and their limits; the `works` entry also sets `works()`. Read lazily. */
+        this.creatorDetailsRelatedStrips = CREATOR_RELATED_STRIPS;
+        /** `#anchor` of the biography in the contents. Read lazily. */
+        this.creatorDetailsBiographyAnchor = 'opis';
+        /** The objects catalog that "show all" of the works opens. Read lazily. */
+        this.creatorDetailsObjectsPath = '/obiekty';
+        this.creatorDetailsRoute = inject(ActivatedRoute);
+        this.creatorDetailsService = inject(CreatorsService);
+        this.creatorDetailsContext = inject(CreatorsListContext);
+        this.creatorDetailsFileUrl = inject(FileUrlService);
+        this.creatorDetailsSeo = inject(MuseumSeoService);
+        this.creatorDetailsTranslate = inject(TranslateService);
+        this.creatorDetailsDocument = inject(DOCUMENT);
+        this.creatorDetailsScroller = inject(ViewportScroller);
+        this.creatorDetailsInjector = inject(Injector);
+        this.creatorDetailsIsBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+        this.creatorDetailsRetry$ = new Subject();
+        this.creatorDetailsRelatedRequest$ = new Subject();
+        this.creatorDetailsRelated = signal(CREATOR_DETAILS_NO_RELATED, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "creatorDetailsRelated" }] : /* istanbul ignore next */ []));
+        this.creatorDetailsFragment = toSignal(this.creatorDetailsRoute.fragment, { initialValue: null });
+        /** `id#fragment` already scrolled to: later data does not jump again. */
+        this.creatorDetailsHandledFragment = null;
+        this.creatorDetailsStopFragmentScroll = () => undefined;
+        this.state = toSignal(combineLatest([
+            this.creatorDetailsRoute.paramMap.pipe(map((params) => params.get('id') ?? ''), distinctUntilChanged()),
+            this.creatorDetailsRetry$.pipe(startWith(undefined)),
+        ]).pipe(switchMap(([id]) => this.creatorDetailsLoad(id))), { initialValue: CREATOR_DETAILS_LOADING });
+        this.creator = computed(() => this.state().creator, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "creator" }] : /* istanbul ignore next */ []));
+        /** museum-artists' name of `creator`. */
+        this.artist = this.creator;
+        /** The name without markup. */
+        this.plainName = computed(() => creatorPlainName(this.creator()?.name), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "plainName" }] : /* istanbul ignore next */ []));
+        /** "Kobro, Katarzyna" gives "Katarzyna Kobro", as in the page heading. */
+        this.name = computed(() => creatorDisplayName(this.plainName()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "name" }] : /* istanbul ignore next */ []));
+        /** Years under the name (`creatorYears`), `''` without dates. */
+        this.years = computed(() => {
+            const creator = this.creator();
+            return creator ? creatorYears(creator) : '';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "years" }] : /* istanbul ignore next */ []));
+        /** Roles, comma separated; a numeric role id is never shown. */
+        this.roles = computed(() => creatorRoles(this.creator()).join(', '), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "roles" }] : /* istanbul ignore next */ []));
+        /** Period, birth and death (museum-artists' order), empty values dropped. */
+        this.details = computed(() => {
+            const creator = this.creator();
+            const keys = this.creatorDetailsKeys;
+            const rows = [
+                { labelKey: keys.period, value: creatorDictLabel(creator?.period) },
+                { labelKey: keys.birth, value: creator?.placeDateOfBirth ?? '' },
+                { labelKey: keys.death, value: creator?.placeDateOfDeath ?? '' },
+            ];
+            return rows.filter((row) => !!row.value);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "details" }] : /* istanbul ignore next */ []));
+        /**
+         * The editorial biography, else the biography, else the description html, trimmed (`creatorBiography`); a field
+         * that only looks filled (`<p>&nbsp;</p>`, Word's MSO blocks) is skipped; `''` without any.
+         */
+        this.biography = computed(() => creatorBiography(this.creator()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "biography" }] : /* istanbul ignore next */ []));
+        /** A biography longer than the folded view (about six lines). */
+        this.foldable = computed(() => creatorIsLongBiography(this.biography()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "foldable" }] : /* istanbul ignore next */ []));
+        /** Plain-text start of the biography for the folded view. */
+        this.excerpt = computed(() => creatorBiographyExcerpt(this.biography()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "excerpt" }] : /* istanbul ignore next */ []));
+        /** The folded biography is unfolded; folded again for another biography. */
+        this.expanded = linkedSignal({ ...(ngDevMode ? { debugName: "expanded" } : /* istanbul ignore next */ {}), source: this.biography,
+            computation: () => false });
+        /** Portrait (`photo`): a ready `url`, else a MUZA file; `null` without one. */
+        this.portrait = computed(() => this.creatorDetailsImageOf(this.creator()?.photo), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "portrait" }] : /* istanbul ignore next */ []));
+        /** Lead artwork (`artworkFrame`), as `portrait`. */
+        this.leadImage = computed(() => this.creatorDetailsImageOf(this.creator()?.artworkFrame), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "leadImage" }] : /* istanbul ignore next */ []));
+        /** Tags with a name. */
+        this.tags = computed(() => (this.creator()?.tags ?? []).filter((tag) => !!tag?.name?.trim()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "tags" }] : /* istanbul ignore next */ []));
+        /**
+         * Per activity period: `from-to` years and the location names, entries with neither dropped. As in
+         * Ossolineum, `[]` when no period has locations; otherwise every period, years-only ones too.
+         */
+        this.activityPlaces = computed(() => {
+            const places = (this.creator()?.activityPeriod ?? [])
+                .map((period) => ({
+                years: [period?.fromYear, period?.toYear]
+                    // The API may send numbers, as it does for `id` and `role`.
+                    .map((year) => String(year ?? '').trim())
+                    .filter(Boolean)
+                    .join('-'),
+                places: (period?.locations ?? [])
+                    .map((location) => creatorPlainName(location?.name))
+                    .filter(Boolean)
+                    .join(', '),
+            }))
+                .filter((place) => place.years || place.places);
+            return places.some((place) => place.places) ? places : [];
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "activityPlaces" }] : /* istanbul ignore next */ []));
+        /** Bibliography entries as plain text (`text`, else `html`), empty ones dropped. */
+        this.bibliography = computed(() => (this.creator()?.bibliographies ?? [])
+            .map((entry) => creatorPlainName(entry?.text || entry?.html))
+            .filter(Boolean), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "bibliography" }] : /* istanbul ignore next */ []));
+        /** `identifier [base]` links of the authority files; only `http(s)://` URLs. */
+        this.authorityLinks = computed(() => (this.creator()?.baseConnectionObjects ?? []).reduce((links, entry) => {
+            const url = entry?.bcUrl?.trim() ?? '';
+            if (!CREATOR_DETAILS_HTTP_URL.test(url))
+                return links;
+            const base = creatorPlainName(entry?.bcBase?.name);
+            const label = [
+                creatorPlainName(entry?.bcIdentifier),
+                base ? `[${base}]` : '',
+            ]
+                .filter(Boolean)
+                .join(' ');
+            links.push({ label: label || url, url });
+            return links;
+        }, []), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "authorityLinks" }] : /* istanbul ignore next */ []));
+        /** Signature objects, else one image of the creator, else `[]`. */
+        this.gallery = computed(() => this.creatorDetailsGalleryOf(this.creator()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "gallery" }] : /* istanbul ignore next */ []));
+        /** The first works of the creator (its id only, no list filter), from the `works` strip entry. */
+        this.works = computed(() => this.creatorDetailsRelated().lists.works?.items ?? [], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "works" }] : /* istanbul ignore next */ []));
+        this.worksTotal = computed(() => this.creatorDetailsRelated().lists.works?.total ?? 0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "worksTotal" }] : /* istanbul ignore next */ []));
+        /** Also `true` while the creator loads: the related lists are requested once it has loaded. */
+        this.worksLoading = computed(() => this.state().status === 'loading' || this.creatorDetailsRelated().loading, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "worksLoading" }] : /* istanbul ignore next */ []));
+        /** `?filter=` of the objects list with this creator, for the "all works" link. */
+        this.worksListQueryParams = computed(() => {
+            const creator = this.creator();
+            if (!creator)
+                return null;
+            // Dictionary ids of the objects catalog are numbers; the service keys creators on strings.
+            const id = CREATOR_DETAILS_NUMERIC_ID.test(creator.id)
+                ? Number(creator.id)
+                : creator.id;
+            return catalogEntryFilterParams('creators', id, this.plainName());
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "worksListQueryParams" }] : /* istanbul ignore next */ []));
+        /**
+         * The related strips with results, in the configured order (an empty strip is left out, with its contents
+         * entry); `[]` while they load. Each item goes through `creatorDetailsRelatedItem`.
+         */
+        this.strips = computed(() => {
+            const { lists } = this.creatorDetailsRelated();
+            return this.creatorDetailsRelatedStrips.reduce((strips, { key, anchor, labelKey, pageSize }) => {
+                const list = lists[key];
+                if (!list?.items.length)
+                    return strips;
+                const query = key === 'works' ? this.worksListQueryParams() : null;
+                strips.push({
+                    key,
+                    anchor,
+                    labelKey,
+                    pageSize,
+                    count: list.total,
+                    items: list.items.map((item) => this.creatorDetailsRelatedItem(item, key)),
+                    showAll: query
+                        ? { commands: [this.creatorDetailsObjectsPath], queryParams: query }
+                        : null,
+                });
+                return strips;
+            }, []);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "strips" }] : /* istanbul ignore next */ []));
+        /** The contents: the biography and the strips the page has. */
+        this.toc = computed(() => [
+            ...(this.biography()
+                ? [
+                    {
+                        anchor: this.creatorDetailsBiographyAnchor,
+                        labelKey: this.creatorDetailsKeys.biographyToc,
+                    },
+                ]
+                : []),
+            ...this.strips().map(({ anchor, labelKey }) => ({ anchor, labelKey })),
+        ], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "toc" }] : /* istanbul ignore next */ []));
+        /** Read out after `share()` copied the link. */
+        this.shareStatus = signal('', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "shareStatus" }] : /* istanbul ignore next */ []));
+        /** Prev/next from the last shown list; none for a deep link, SSR or a creator outside it. */
+        this.neighbours = computed(() => this.creatorDetailsContext.neighbours(this.creator()?.id), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "neighbours" }] : /* istanbul ignore next */ []));
+        this.prevCommands = computed(() => {
+            const prev = this.neighbours().prev;
+            return prev ? creatorDetailsCommands(this.creatorDetailsPath, prev) : null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "prevCommands" }] : /* istanbul ignore next */ []));
+        this.nextCommands = computed(() => {
+            const next = this.neighbours().next;
+            return next ? creatorDetailsCommands(this.creatorDetailsPath, next) : null;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "nextCommands" }] : /* istanbul ignore next */ []));
+        /** `[path, id, slug]` of the loaded creator; `[]` without one. */
+        this.canonicalCommands = computed(() => {
+            const creator = this.creator();
+            return creator
+                ? creatorDetailsCommands(this.creatorDetailsPath, creator)
+                : [];
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "canonicalCommands" }] : /* istanbul ignore next */ []));
+        /** The index letter of the creator; `''` without one. */
+        this.backLetter = computed(() => {
+            const creator = this.creator();
+            return creator ? creatorsLetterOf(creator.name ?? '') : '';
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "backLetter" }] : /* istanbul ignore next */ []));
+        /** The two-letter group of the creator in the index (MOB-1959); `''` without one. */
+        this.backPrefix = computed(() => creatorsIndexPrefixOf(this.creator()?.name ?? ''), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "backPrefix" }] : /* istanbul ignore next */ []));
+        /** The index opens on the creator's letter and two-letter group (MOB-1959). */
+        this.backQueryParams = computed(() => {
+            if (!this.creator())
+                return {};
+            const params = {
+                [CREATORS_INDEX_LETTER_PARAM]: this.backLetter(),
+            };
+            const prefix = this.backPrefix();
+            // Like sztuki (`backPrefix() || null`): no empty `prefiks=`.
+            if (prefix)
+                params[CREATORS_INDEX_PREFIX_PARAM] = prefix;
+            return params;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "backQueryParams" }] : /* istanbul ignore next */ []));
+        /** Ossolineum's section accordions; both open at first. */
+        this.biographyOpen = signal(true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "biographyOpen" }] : /* istanbul ignore next */ []));
+        this.bibliographyOpen = signal(true, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "bibliographyOpen" }] : /* istanbul ignore next */ []));
+        this.creatorDetailsSeo.applyForSsr(() => this.creatorDetailsFetchSsrSeo());
+        const destroyRef = inject(DestroyRef);
+        destroyRef.onDestroy(() => this.creatorDetailsStopFragmentScroll());
+        this.creatorDetailsRelatedRequest$
+            .pipe(distinctUntilChanged((a, b) => a?.id === b?.id), switchMap((creator) => this.creatorDetailsLoadRelated(creator)), takeUntilDestroyed(destroyRef))
+            .subscribe((related) => this.creatorDetailsRelated.set(related));
+        effect(() => {
+            const creator = this.creator();
+            untracked(() => this.creatorDetailsRelatedRequest$.next(creator));
+        });
+        // The router scrolls to the fragment on NavigationEnd, before the biography and the strips load:
+        // `/artysci/:id#dziela` (back, an outside link) is scrolled here once its part is in the contents.
+        effect(() => {
+            const fragment = this.creatorDetailsFragment();
+            const id = this.creator()?.id;
+            if (!fragment)
+                this.creatorDetailsHandledFragment = null;
+            if (!fragment || !id)
+                return;
+            const key = `${id}#${fragment}`;
+            if (key === this.creatorDetailsHandledFragment)
+                return;
+            if (!this.toc().some(({ anchor }) => anchor === fragment))
+                return;
+            this.creatorDetailsHandledFragment = key;
+            afterNextRender({ read: () => this.creatorDetailsScrollToFragment(fragment) }, { injector: this.creatorDetailsInjector });
+        });
+        effect(() => {
+            const { status, creator } = this.state();
+            untracked(() => {
+                if (creator) {
+                    this.creatorDetailsSeo.apply(this.creatorDetailsSeoOf(creator));
+                }
+                else if (status === 'not-found') {
+                    const keys = this.creatorDetailsKeys;
+                    this.creatorDetailsSeo.apply({
+                        title: `${this.creatorDetailsT(keys.notFoundKey)} - ${this.creatorDetailsT(keys.siteNameKey)}`,
+                    });
+                }
+            });
+        });
+    }
+    retry() {
+        this.creatorDetailsRetry$.next();
+    }
+    /** Unfolds or folds the long biography (museum-artists' "rozwiń tekst"). */
+    toggleBiography() {
+        this.expanded.update((value) => !value);
+    }
+    /** Opens or closes Ossolineum's biography accordion. */
+    toggleBiographyOpen() {
+        this.biographyOpen.update((open) => !open);
+    }
+    toggleBibliography() {
+        this.bibliographyOpen.update((open) => !open);
+    }
+    /** The system share, else the link to the clipboard (announced in `shareStatus`). Browser only. */
+    async share() {
+        const view = this.creatorDetailsDocument.defaultView;
+        if (!this.creatorDetailsIsBrowser || !view)
+            return;
+        const url = view.location.href;
+        const navigator = view.navigator;
+        try {
+            if (typeof navigator.share === 'function') {
+                await navigator.share({ title: this.name(), url });
+                return;
+            }
+            await navigator.clipboard.writeText(url);
+            this.shareStatus.set(this.creatorDetailsT(this.creatorDetailsKeys.shareCopied));
+        }
+        catch {
+            // A cancelled share sheet or no clipboard access: no message.
+        }
+    }
+    /** A strip item as the museum shows it (sztuki: a result card); the object itself by default. */
+    creatorDetailsRelatedItem(item, key) {
+        void key;
+        return item;
+    }
+    /**
+     * The `<title>` of a creator: `plainName - t(sectionKey) - t(siteNameKey)` (the section left out for a `null`
+     * `sectionKey`). Override to keep another format; sztuki keeps `name() - t('museumName')`. Called lazily, for the
+     * page and on the server.
+     */
+    creatorDetailsSeoTitle(creator) {
+        const keys = this.creatorDetailsKeys;
+        return [
+            creatorPlainName(creator.name),
+            keys.sectionKey ? this.creatorDetailsT(keys.sectionKey) : '',
+            this.creatorDetailsT(keys.siteNameKey),
+        ]
+            .filter(Boolean)
+            .join(' - ');
+    }
+    creatorDetailsLoad(id) {
+        return this.creatorDetailsService.getById(id).pipe(map((creator) => creator ? { status: 'success', creator } : CREATOR_DETAILS_NOT_FOUND), catchError(() => of({ status: 'error', creator: null })), startWith(CREATOR_DETAILS_LOADING));
+    }
+    /**
+     * Runs from the effect, after construction, so the strip overrides are in place. A list that fails is empty;
+     * the rest of the page stays.
+     */
+    creatorDetailsLoadRelated(creator) {
+        const strips = this.creatorDetailsRelatedStrips;
+        if (!creator || !strips.length)
+            return of(CREATOR_DETAILS_NO_RELATED);
+        return combineLatest(strips.map(({ key, limit }) => (key === 'works'
+            ? this.creatorDetailsService.getWorks(creator.id, limit)
+            : this.creatorDetailsService.getRelated(creator[key], limit)).pipe(catchError(() => of(CREATOR_DETAILS_NO_OBJECTS)), map((list) => [key, list])))).pipe(map((entries) => ({
+            loading: false,
+            lists: entries.reduce((lists, [key, list]) => ({ ...lists, [key]: list }), {}),
+        })), startWith({
+            ...CREATOR_DETAILS_NO_RELATED,
+            loading: true,
+        }));
+    }
+    /**
+     * Scrolls to the anchor and holds it there for a moment: the lead artwork and the strips may still change the
+     * height above it. The user's own scroll ends the corrections. Runs after render, in the browser only.
+     */
+    creatorDetailsScrollToFragment(fragment) {
+        this.creatorDetailsStopFragmentScroll();
+        this.creatorDetailsScroller.scrollToAnchor(fragment);
+        const view = this.creatorDetailsDocument.defaultView;
+        if (!view || typeof view.ResizeObserver === 'undefined')
+            return;
+        const observer = new view.ResizeObserver(() => this.creatorDetailsScroller.scrollToAnchor(fragment));
+        const stop = () => {
+            observer.disconnect();
+            view.clearTimeout(timer);
+            CREATOR_DETAILS_USER_SCROLL_EVENTS.forEach((name) => view.removeEventListener(name, stop));
+            this.creatorDetailsStopFragmentScroll = () => undefined;
+        };
+        const timer = view.setTimeout(stop, CREATOR_DETAILS_FRAGMENT_SETTLE_MS);
+        observer.observe(this.creatorDetailsDocument.body);
+        CREATOR_DETAILS_USER_SCROLL_EVENTS.forEach((name) => view.addEventListener(name, stop, { passive: true }));
+        this.creatorDetailsStopFragmentScroll = stop;
+    }
+    /** `creator/{id}` gives a ready `url`; a MUZA file (`filePath`) goes through `FileUrlService`. */
+    creatorDetailsImageOf(file) {
+        if (!file)
+            return null;
+        const url = 'url' in file ? (file.url?.trim() ?? '') : '';
+        const src = url ||
+            ('filePath' in file && file.filePath
+                ? this.creatorDetailsFileUrl.get(file, 'cache')
+                : '');
+        return src ? { src, alt: file.altText || '' } : null;
+    }
+    creatorDetailsGalleryOf(creator) {
+        if (!creator)
+            return [];
+        const name = creatorPlainName(creator.name);
+        const signatures = (creator.signatureObjects ?? []).reduce((images, entry) => {
+            const file = entry?.image ?? entry?.file;
+            if (!file)
+                return images;
+            const title = creatorPlainName(entry?.title);
+            images.push({
+                src: this.creatorDetailsFileUrl.get(file, 'cache'),
+                alt: title || name,
+                ...(title ? { title } : {}),
+            });
+            return images;
+        }, []);
+        if (signatures.length)
+            return signatures;
+        const extra = creator.extraData?.image?.trim();
+        if (extra)
+            return [{ src: extra, alt: name }];
+        const { image } = creator;
+        if (typeof image === 'string' && image.trim()) {
+            return [{ src: image.trim(), alt: name }];
+        }
+        if (image && typeof image === 'object') {
+            return [
+                { src: this.creatorDetailsFileUrl.get(image, 'cache'), alt: name },
+            ];
+        }
+        return [];
+    }
+    /** `creatorDetailsSeoTitle`, the plain biography (`creatorBiography`), the first image, the canonical. */
+    creatorDetailsSeoOf(creator) {
+        const title = this.creatorDetailsSeoTitle(creator);
+        const url = creatorDetailsCommands(this.creatorDetailsPath, creator).join('/');
+        const metadata = {
+            title,
+            description: creatorPlainText(creatorBiography(creator)) || undefined,
+            // A path override without the leading slash still gives an absolute canonical.
+            url: url.startsWith('/') ? url : `/${url}`,
+            type: 'article',
+        };
+        const image = this.creatorDetailsGalleryOf(creator)[0]?.src;
+        if (image)
+            metadata.image = image;
+        return metadata;
+    }
+    creatorDetailsFetchSsrSeo() {
+        const id = this.creatorDetailsRoute.snapshot.paramMap.get('id') ?? '';
+        return firstValueFrom(this.creatorDetailsService.getById(id))
+            .then((creator) => (creator ? this.creatorDetailsSeoOf(creator) : null))
+            .catch(() => null);
+    }
+    creatorDetailsT(key) {
+        return String(this.creatorDetailsTranslate.instant(key) ?? '');
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorDetailsBaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.3", type: CreatorDetailsBaseComponent, isStandalone: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: CreatorDetailsBaseComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CREATORS_ALPHABET, CREATORS_CATALOG_DEFAULTS, CREATORS_HASH_PREFIXES, CREATORS_INDEX_LETTER_PARAM, CREATORS_INDEX_PREFIX_PARAM, CREATORS_SEARCH_LIMIT, CREATORS_SEARCH_PAGE_SIZES, CREATOR_DETAILS_KEYS, CREATOR_RELATED_STRIPS, CreatorCardBaseComponent, CreatorDetailsBaseComponent, CreatorsCatalogBaseComponent, CreatorsFiltersBaseComponent, CreatorsIndexBaseComponent, CreatorsJumpToBaseComponent, CreatorsListContext, CreatorsSearchListBaseComponent, CreatorsService, EMPTY_CREATORS_FILTER, createCreatorsCatalog, createCreatorsFacade, creatorBiography, creatorBiographyExcerpt, creatorDetailsCommands, creatorDictLabel, creatorDictionaryUrl, creatorDisplayName, creatorIsLongBiography, creatorLifeYears, creatorNfdLetter, creatorPlainName, creatorPlainText, creatorProfileUrl, creatorRelatedUrl, creatorRoles, creatorSlug, creatorWorksUrl, creatorYears, creatorsDisplayPrefix, creatorsFilterQueryParams, creatorsFilterToQuery, creatorsFilterValueOf, creatorsFindPrefix, creatorsIndexPrefixOf, creatorsLetterOf, creatorsListSeoMetadata, creatorsListUrl, creatorsPrefixAnchor, creatorsPrefixOf, creatorsPrefixesUrl, groupCreatorsByLetter, groupCreatorsByPrefix, hasCreatorsFilter, isCreatorsBirthRangeValid, isCreatorsBirthYear, parseCreatorsLetter, resolveCreatorsFragment };
+//# sourceMappingURL=smartsoft001-mobilems-creators-shell-angular.mjs.map