@museumwnf/viewer-core 1.14.0 → 1.15.1

package/src/record/derivations.js

@@ -1,154 +1,154 @@
-import { computed, ref, toValue } from 'vue'
-import { useDataPackage } from '../composables/useDataPackage.js'
-import { byId, entityRef } from '../composables/useEntities.js'
-import { renderPlain } from '../i18n/markdown.js'
-import { roundOutward } from '../catalogue/dates.js'
-
-const BASE_LANGUAGE = 'en'
-
-// Four derivations every record page makes, written seven times.
-
-// ── The glossary popup ─────────────────────────────────────────────────────
-//
-// The renderer marks every glossary spelling as
-// `<span class="gloss-term" data-gid="…">` while it parses. Those spans are
-// inside `v-html`, so nothing binds to them one by one: one listener on the
-// container reads the click and answers with the term.
-
-/**
- * `{ active, onClick, close }`: attach `onClick` to the element the sheet
- * renders into; `active` is `{ id, word, spelling, definition }` for the
- * term clicked, null otherwise. `entries` is the `glossary` list of
- * `useRecordSheet` (a ref, getter or array).
- */
-export function useGlossaryPopup(entries) {
-  const active = ref(null)
-  function onClick(event) {
-    const element = event?.target?.closest?.('.gloss-term')
-    if (!element) return
-    event.preventDefault()
-    const id = element.dataset.gid
-    const entry = (toValue(entries) ?? []).find((e) => e.id === id)
-    active.value = {
-      id,
-      spelling: element.textContent,
-      word: entry?.word ?? element.textContent,
-      definition: entry?.definition ?? '',
-    }
-  }
-  function close() {
-    active.value = null
-  }
-  return { active, onClick, close }
-}
-
-/**
- * The glossary terms whose spelling starts with `input`, in `language`
- * (falling back to English), for a glossary search box: `[{ id, word,
- * spelling, definition }]`, one per term, sorted by spelling.
- */
-export function searchGlossary(input, language, { entity = 'glossary' } = {}) {
-  const needle = String(input ?? '').trim().toLowerCase()
-  if (!needle) return []
-  const { translations } = useDataPackage()
-  const rows = translations(entity, language)
-  const fallback = translations(entity, BASE_LANGUAGE)
-  const out = []
-  for (const term of entityRef(entity).value ?? []) {
-    const t = rows[term.id] ?? fallback[term.id] ?? {}
-    const spellings = t.spellings?.length ? t.spellings : [term.word]
-    for (const spelling of spellings) {
-      if (String(spelling ?? '').toLowerCase().startsWith(needle)) {
-        out.push({ id: term.id, word: term.word, spelling: String(spelling).trim(), definition: t.definition ?? '' })
-        break
-      }
-    }
-  }
-  return out.sort((a, b) => a.spelling.localeCompare(b.spelling))
-}
-
-// ── Citation ───────────────────────────────────────────────────────────────
-
-/**
- * The sentence both families print under a sheet:
- * `Author "Name" in Project, Publisher, Year. Permalink` — assembled here in
- * that order, from parts, rather than written into a text with holes in it.
- * `inWord` is the site's `t('record.citation.in')`. Parts that are missing
- * are left out with their punctuation.
- */
-export function citation({ author, name, project, publisher = 'Museum With No Frontiers', year, permalink, inWord = 'in' } = {}) {
-  const title = renderPlain(name ?? '')
-  if (!title) return ''
-  const when = year ?? new Date().getFullYear()
-  const where = [project, publisher].filter(Boolean).join(', ')
-  const parts = []
-  if (author) parts.push(String(author).trim())
-  parts.push(`"${title}"`)
-  if (where) parts.push(`${inWord} ${where},`)
-  let sentence = `${parts.join(' ')} ${when}.`
-  if (permalink) sentence += ` ${permalink}`
-  return sentence
-}
-
-// ── Related records ────────────────────────────────────────────────────────
-
-/**
- * A record's `related_items`, split by whether the package carries them:
- * `inPackage` is `[{ reference, record, justification }]` with the
- * justification in `language` (falling back to English); `outside` is the
- * references the package does not hold, kept as the references they are — a
- * link is never dropped for being unresolvable, and never invented either.
- */
-export function relatedRecords(record, { entity = 'items', language = BASE_LANGUAGE, field = 'related_items' } = {}) {
-  const index = byId(entity).value
-  const inPackage = []
-  const outside = []
-  const seen = new Set()
-  for (const reference of record?.[field] ?? []) {
-    if (!reference || seen.has(reference.id)) continue
-    seen.add(reference.id)
-    const found = reference.in_package === false ? null : index.get(reference.id)
-    if (!found) {
-      outside.push(reference)
-      continue
-    }
-    const justifications = reference.justifications ?? {}
-    inPackage.push({
-      reference,
-      record: found,
-      justification: justifications[language] ?? justifications[BASE_LANGUAGE] ?? '',
-    })
-  }
-  return { inPackage, outside }
-}
-
-/** `relatedRecords` over reactive sources. */
-export function useRelatedRecords(record, options = {}) {
-  return computed(() => relatedRecords(toValue(record), { ...options, language: toValue(options.language) ?? BASE_LANGUAGE }))
-}
-
-// ── The timeline link ──────────────────────────────────────────────────────
-
-/**
- * The route location of the timeline results for a record's country and
- * dates, or null when the record has neither a country nor a date. `name`
- * is the site's timeline-results route; `keys` the query keys it reads
- * (`country`, `begin`, `end` by default); `country(record)` the value the
- * route wants for the country (the id by default — a site whose timeline
- * reads legacy codes passes its own); `round` rounds the dates outward to
- * the century, as the DXA "Timeline for this item" does.
- */
-export function timelineLinkFor(record, { name = 'timeline-results', keys = {}, country, round = false } = {}) {
-  if (!record) return null
-  const countryValue = country ? country(record) : record.country_id
-  const start = typeof record.start_date === 'number' ? record.start_date : null
-  const end = typeof record.end_date === 'number' ? record.end_date : null
-  if (!countryValue && start == null && end == null) return null
-  let [from, to] = [start, end]
-  if (round) [from, to] = roundOutward(start ?? undefined, end ?? undefined)
-  const query = {}
-  if (countryValue) query[keys.country ?? 'country'] = String(countryValue)
-  if (from != null) query[keys.begin ?? 'begin'] = String(from)
-  if (to != null) query[keys.end ?? 'end'] = String(to)
-  return { name, query }
-}
+import { computed, ref, toValue } from 'vue'
+import { useDataPackage } from '../composables/useDataPackage.js'
+import { byId, entityRef } from '../composables/useEntities.js'
+import { renderPlain } from '../i18n/markdown.js'
+import { roundOutward } from '../catalogue/dates.js'
+
+const BASE_LANGUAGE = 'en'
+
+// Four derivations every record page makes, written seven times.
+
+// ── The glossary popup ─────────────────────────────────────────────────────
+//
+// The renderer marks every glossary spelling as
+// `<span class="gloss-term" data-gid="…">` while it parses. Those spans are
+// inside `v-html`, so nothing binds to them one by one: one listener on the
+// container reads the click and answers with the term.
+
+/**
+ * `{ active, onClick, close }`: attach `onClick` to the element the sheet
+ * renders into; `active` is `{ id, word, spelling, definition }` for the
+ * term clicked, null otherwise. `entries` is the `glossary` list of
+ * `useRecordSheet` (a ref, getter or array).
+ */
+export function useGlossaryPopup(entries) {
+  const active = ref(null)
+  function onClick(event) {
+    const element = event?.target?.closest?.('.gloss-term')
+    if (!element) return
+    event.preventDefault()
+    const id = element.dataset.gid
+    const entry = (toValue(entries) ?? []).find((e) => e.id === id)
+    active.value = {
+      id,
+      spelling: element.textContent,
+      word: entry?.word ?? element.textContent,
+      definition: entry?.definition ?? '',
+    }
+  }
+  function close() {
+    active.value = null
+  }
+  return { active, onClick, close }
+}
+
+/**
+ * The glossary terms whose spelling starts with `input`, in `language`
+ * (falling back to English), for a glossary search box: `[{ id, word,
+ * spelling, definition }]`, one per term, sorted by spelling.
+ */
+export function searchGlossary(input, language, { entity = 'glossary' } = {}) {
+  const needle = String(input ?? '').trim().toLowerCase()
+  if (!needle) return []
+  const { translations } = useDataPackage()
+  const rows = translations(entity, language)
+  const fallback = translations(entity, BASE_LANGUAGE)
+  const out = []
+  for (const term of entityRef(entity).value ?? []) {
+    const t = rows[term.id] ?? fallback[term.id] ?? {}
+    const spellings = t.spellings?.length ? t.spellings : [term.word]
+    for (const spelling of spellings) {
+      if (String(spelling ?? '').toLowerCase().startsWith(needle)) {
+        out.push({ id: term.id, word: term.word, spelling: String(spelling).trim(), definition: t.definition ?? '' })
+        break
+      }
+    }
+  }
+  return out.sort((a, b) => a.spelling.localeCompare(b.spelling))
+}
+
+// ── Citation ───────────────────────────────────────────────────────────────
+
+/**
+ * The sentence both families print under a sheet:
+ * `Author "Name" in Project, Publisher, Year. Permalink` — assembled here in
+ * that order, from parts, rather than written into a text with holes in it.
+ * `inWord` is the site's `t('record.citation.in')`. Parts that are missing
+ * are left out with their punctuation.
+ */
+export function citation({ author, name, project, publisher = 'Museum With No Frontiers', year, permalink, inWord = 'in' } = {}) {
+  const title = renderPlain(name ?? '')
+  if (!title) return ''
+  const when = year ?? new Date().getFullYear()
+  const where = [project, publisher].filter(Boolean).join(', ')
+  const parts = []
+  if (author) parts.push(String(author).trim())
+  parts.push(`"${title}"`)
+  if (where) parts.push(`${inWord} ${where},`)
+  let sentence = `${parts.join(' ')} ${when}.`
+  if (permalink) sentence += ` ${permalink}`
+  return sentence
+}
+
+// ── Related records ────────────────────────────────────────────────────────
+
+/**
+ * A record's `related_items`, split by whether the package carries them:
+ * `inPackage` is `[{ reference, record, justification }]` with the
+ * justification in `language` (falling back to English); `outside` is the
+ * references the package does not hold, kept as the references they are — a
+ * link is never dropped for being unresolvable, and never invented either.
+ */
+export function relatedRecords(record, { entity = 'items', language = BASE_LANGUAGE, field = 'related_items' } = {}) {
+  const index = byId(entity).value
+  const inPackage = []
+  const outside = []
+  const seen = new Set()
+  for (const reference of record?.[field] ?? []) {
+    if (!reference || seen.has(reference.id)) continue
+    seen.add(reference.id)
+    const found = reference.in_package === false ? null : index.get(reference.id)
+    if (!found) {
+      outside.push(reference)
+      continue
+    }
+    const justifications = reference.justifications ?? {}
+    inPackage.push({
+      reference,
+      record: found,
+      justification: justifications[language] ?? justifications[BASE_LANGUAGE] ?? '',
+    })
+  }
+  return { inPackage, outside }
+}
+
+/** `relatedRecords` over reactive sources. */
+export function useRelatedRecords(record, options = {}) {
+  return computed(() => relatedRecords(toValue(record), { ...options, language: toValue(options.language) ?? BASE_LANGUAGE }))
+}
+
+// ── The timeline link ──────────────────────────────────────────────────────
+
+/**
+ * The route location of the timeline results for a record's country and
+ * dates, or null when the record has neither a country nor a date. `name`
+ * is the site's timeline-results route; `keys` the query keys it reads
+ * (`country`, `begin`, `end` by default); `country(record)` the value the
+ * route wants for the country (the id by default — a site whose timeline
+ * reads legacy codes passes its own); `round` rounds the dates outward to
+ * the century, as the DXA "Timeline for this item" does.
+ */
+export function timelineLinkFor(record, { name = 'timeline-results', keys = {}, country, round = false } = {}) {
+  if (!record) return null
+  const countryValue = country ? country(record) : record.country_id
+  const start = typeof record.start_date === 'number' ? record.start_date : null
+  const end = typeof record.end_date === 'number' ? record.end_date : null
+  if (!countryValue && start == null && end == null) return null
+  let [from, to] = [start, end]
+  if (round) [from, to] = roundOutward(start ?? undefined, end ?? undefined)
+  const query = {}
+  if (countryValue) query[keys.country ?? 'country'] = String(countryValue)
+  if (from != null) query[keys.begin ?? 'begin'] = String(from)
+  if (to != null) query[keys.end ?? 'end'] = String(to)
+  return { name, query }
+}

package/src/record/partners.js

@@ -1,87 +1,87 @@
-// Seven partner lists group by country seven ways. The standalone sites
-// (islamicart, baroqueart, sharinghistory) bucket each country's partners
-// into "main" and "associated" on a `level` field and render an accordion;
-// the DXA sites (carpets and its siblings) group the same way but add an
-// A-Z / Z-A toggle and no tiers at all. Both are this one derivation with a
-// couple of options — pure, so the site's own view supplies the toggle and
-// the label lookup.
-//
-// `parent_id` is carried on a third of the standalone partners and read
-// nowhere: legacy nested an associated partner under the main partner it
-// belongs to, and the port flattened that into the country column instead.
-// `partnerHierarchy` is that relationship, read once.
-
-/**
- * Whether `record` counts as a main (rather than associated) partner.
- * `tier` names the field the converged partner shape carries (`level`).
- * A record is associated only when its tier value is a non-empty value
- * other than `'partner'` (legacy values: `'associated_partner'`,
- * `'minor_contributor'`); `null`, `undefined`, `''`, or `'partner'` mean
- * main. This is necessary because exporters emit `level: null` for every
- * partner without curated hierarchy. Without a `tier` at all there is nothing
- * to divide records on, so every record is main, which is what a caller with
- * no tiers (the DXA lists) wants.
- */
-function isMainTier(record, tier) {
-  if (!tier) return true
-  const tierValue = record?.[tier]
-  // Treat null, undefined, empty string, or 'partner' as main
-  return tierValue == null || tierValue === '' || tierValue === 'partner'
-}
-
-/**
- * Partner records grouped by country: `[{ country, label, main, associated
- * }]`, one entry per distinct `country_id` (partners with none share a
- * `null` group), sorted by `label`, ascending unless `order: 'desc'`.
- * `label(country)` names a group's country — the caller's own lookup, the
- * same shape as a facet's `label(value)` — since a partner record carries
- * only the id. `tier` names the field that marks a main partner (see
- * `isMainTier`); without it every record lands in `main` and `associated`
- * is always empty, which covers the DXA lists' plain grouping. Partners
- * keep the relative order `records` was given in within each tier — sorting
- * them by their own label is the view's concern, not this derivation's.
- */
-export function groupByCountry(records, { label, tier, order = 'asc' } = {}) {
-  const groups = new Map()
-  for (const record of records ?? []) {
-    const country = record?.country_id ?? null
-    if (!groups.has(country)) groups.set(country, { country, main: [], associated: [] })
-    const group = groups.get(country)
-    ;(isMainTier(record, tier) ? group.main : group.associated).push(record)
-  }
-  const rows = [...groups.values()].map((group) => ({ ...group, label: label ? label(group.country) : group.country }))
-  rows.sort((a, b) => String(a.label).localeCompare(String(b.label)))
-  return order === 'desc' ? rows.reverse() : rows
-}
-
-/**
- * The partner hierarchy `parent_id` encodes: `children(id)` (a partner's
- * associated partners), `parentOf(id)` (the main partner it belongs to, or
- * null), `roots` (every partner with no parent in the list, or whose
- * `parent_id` points outside it). A partner referencing a `parent_id` this
- * list does not carry is treated as a root rather than dropped — the same
- * "keep the reference, don't invent or discard" rule `relatedRecords` uses.
- */
-export function partnerHierarchy(partners) {
-  const list = partners ?? []
-  const byId = new Map(list.map((partner) => [partner.id, partner]))
-  const childrenOf = new Map()
-  const roots = []
-  for (const partner of list) {
-    const parent = partner?.parent_id != null ? byId.get(partner.parent_id) : null
-    if (parent) {
-      if (!childrenOf.has(parent.id)) childrenOf.set(parent.id, [])
-      childrenOf.get(parent.id).push(partner)
-    } else {
-      roots.push(partner)
-    }
-  }
-  return {
-    children: (id) => childrenOf.get(id) ?? [],
-    parentOf: (id) => {
-      const partner = byId.get(id)
-      return partner?.parent_id != null ? (byId.get(partner.parent_id) ?? null) : null
-    },
-    roots,
-  }
-}
+// Seven partner lists group by country seven ways. The standalone sites
+// (islamicart, baroqueart, sharinghistory) bucket each country's partners
+// into "main" and "associated" on a `level` field and render an accordion;
+// the DXA sites (carpets and its siblings) group the same way but add an
+// A-Z / Z-A toggle and no tiers at all. Both are this one derivation with a
+// couple of options — pure, so the site's own view supplies the toggle and
+// the label lookup.
+//
+// `parent_id` is carried on a third of the standalone partners and read
+// nowhere: legacy nested an associated partner under the main partner it
+// belongs to, and the port flattened that into the country column instead.
+// `partnerHierarchy` is that relationship, read once.
+
+/**
+ * Whether `record` counts as a main (rather than associated) partner.
+ * `tier` names the field the converged partner shape carries (`level`).
+ * A record is associated only when its tier value is a non-empty value
+ * other than `'partner'` (legacy values: `'associated_partner'`,
+ * `'minor_contributor'`); `null`, `undefined`, `''`, or `'partner'` mean
+ * main. This is necessary because exporters emit `level: null` for every
+ * partner without curated hierarchy. Without a `tier` at all there is nothing
+ * to divide records on, so every record is main, which is what a caller with
+ * no tiers (the DXA lists) wants.
+ */
+function isMainTier(record, tier) {
+  if (!tier) return true
+  const tierValue = record?.[tier]
+  // Treat null, undefined, empty string, or 'partner' as main
+  return tierValue == null || tierValue === '' || tierValue === 'partner'
+}
+
+/**
+ * Partner records grouped by country: `[{ country, label, main, associated
+ * }]`, one entry per distinct `country_id` (partners with none share a
+ * `null` group), sorted by `label`, ascending unless `order: 'desc'`.
+ * `label(country)` names a group's country — the caller's own lookup, the
+ * same shape as a facet's `label(value)` — since a partner record carries
+ * only the id. `tier` names the field that marks a main partner (see
+ * `isMainTier`); without it every record lands in `main` and `associated`
+ * is always empty, which covers the DXA lists' plain grouping. Partners
+ * keep the relative order `records` was given in within each tier — sorting
+ * them by their own label is the view's concern, not this derivation's.
+ */
+export function groupByCountry(records, { label, tier, order = 'asc' } = {}) {
+  const groups = new Map()
+  for (const record of records ?? []) {
+    const country = record?.country_id ?? null
+    if (!groups.has(country)) groups.set(country, { country, main: [], associated: [] })
+    const group = groups.get(country)
+    ;(isMainTier(record, tier) ? group.main : group.associated).push(record)
+  }
+  const rows = [...groups.values()].map((group) => ({ ...group, label: label ? label(group.country) : group.country }))
+  rows.sort((a, b) => String(a.label).localeCompare(String(b.label)))
+  return order === 'desc' ? rows.reverse() : rows
+}
+
+/**
+ * The partner hierarchy `parent_id` encodes: `children(id)` (a partner's
+ * associated partners), `parentOf(id)` (the main partner it belongs to, or
+ * null), `roots` (every partner with no parent in the list, or whose
+ * `parent_id` points outside it). A partner referencing a `parent_id` this
+ * list does not carry is treated as a root rather than dropped — the same
+ * "keep the reference, don't invent or discard" rule `relatedRecords` uses.
+ */
+export function partnerHierarchy(partners) {
+  const list = partners ?? []
+  const byId = new Map(list.map((partner) => [partner.id, partner]))
+  const childrenOf = new Map()
+  const roots = []
+  for (const partner of list) {
+    const parent = partner?.parent_id != null ? byId.get(partner.parent_id) : null
+    if (parent) {
+      if (!childrenOf.has(parent.id)) childrenOf.set(parent.id, [])
+      childrenOf.get(parent.id).push(partner)
+    } else {
+      roots.push(partner)
+    }
+  }
+  return {
+    children: (id) => childrenOf.get(id) ?? [],
+    parentOf: (id) => {
+      const partner = byId.get(id)
+      return partner?.parent_id != null ? (byId.get(partner.parent_id) ?? null) : null
+    },
+    roots,
+  }
+}