@museumwnf/viewer-core 2.1.0 → 2.3.0

package/README.md

@@ -470,14 +470,14 @@ under the main partner it belongs to.
 | --- | --- |
 | `groupByCountry(records, { label, tier?, order = 'asc' })` | `[{ country, label, main, associated }]`, one entry per distinct `country_id`, sorted by `label`. `label(country)` names a group's country, the same shape as a facet's `label(value)`. `tier` names the field that marks a main partner (the converged shape's `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. Without a `tier` every record is main, which is the DXA lists' plain grouping. Partners keep the order `records` was given in within each tier. |
 | `partnerHierarchy(partners)` | `{ children(id), parentOf(id), roots }` from `parent_id`: `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. |
-| `partnerView(partner, text, ctx)` | The view-model every rendering of one partner reads — `@museumwnf/viewer-layout`'s `PartnerPanel` in each of its variants: `{ id, type, name (inline HTML), plainName, city, country, location, logos: [{ url, alt, type }], pictures: [{ url, alt, caption, photographer, copyright }], description (block HTML), contact: { address (block HTML), phone, fax, email, website: { url, label } \| null, links: [{ url, label }] }, persons: [{ title, name, phone, fax, email }], hasContact, map: { latitude, longitude, zoom, label } \| null, itemCount, hidden, route, objectsRoute }`. `text` is the partner's translation in the language shown. `ctx` carries only what differs by family: `countryLabel(id)`, the renderers (`md`, `mdInline`, `mdStrip`, the package's by default), `route(partner)`, `objectsRoute(partner)` and `hidden(partner)` (a hidden partner keeps its name and loses both links). Contact persons come from `contact_persons`, in order, keeping those with a name or a title. A picture's caption is its `alt_text`. A website or link with no scheme gets `https://`; any scheme other than `http(s)` is dropped. |
+| `partnerView(partner, text, ctx)` | The view-model every rendering of one partner reads — `@museumwnf/viewer-layout`'s `PartnerPanel` in each of its variants: `{ id, type, name (inline HTML), plainName, city, country, location, logos: [{ url, alt, type }], pictures: [{ url, alt, caption, photographer, copyright }], description (block HTML), contact: { address (block HTML), phone, fax, email, website: { url, label } \| null, links: [{ url, label }] }, persons: [{ title, name, phone, fax, email }], hasContact, map: { latitude, longitude, zoom, label } \| null, itemCount, hidden, route, objectsRoute }`. `text` is the partner's translation in the language shown. `ctx` carries only what differs by family: `countryLabel(id)`, the renderers (`md`, `mdInline`, `mdStrip`, the package's by default), `route(partner)`, `objectsRoute(partner)` and `hidden(partner)` (a hidden partner keeps its name and loses both links). Contact persons come from `contact_persons`, in order, keeping those with a name or a title (the legacy `contact_person_1`/`_2` pair is not read). A picture's caption is its `alt_text`. A website or link with no scheme gets `https://`; any scheme other than `http(s)` is dropped. |
 
 ### Conventions
 
 | Export | Meaning |
 | --- | --- |
 | `useSection()` | the `meta.section` of the current route — see Routing |
-| `useFeaturedRecord(entity, { withImage = true, seed })` | one record at random for a landing page's spotlight, among those with an image; null until the entity is loaded; `seed` pins the pick |
+| `useFeaturedRecord(entity, { withImage = true, seed, filter })` | one record at random for a landing page's spotlight, among those with an image; null until the entity is loaded; `seed` pins the pick; `filter(record)` applies a site's own visible rule first |
 | `sectionMeta(chrome = [])` | returns `meta(section, ...entities) => ({ section, entities: [...chrome, ...entities] })` — a route's `meta` in one call, `chrome` being the entities every page of the site loads regardless of which one it is |
 | `mwnfLinks` | the portal and sibling-site addresses the four DXA configs each repeat under `links` — frozen, spread into a site's own `links` rather than retyped |
 
@@ -566,6 +566,9 @@ below for whichever future site needs its own).
 | `useGalleryPartner(data, collection, config)` / `useExhibitionPartner(data, config)` | `data`, and (gallery only) `collection` for its `tile` | `partnerList`/`partnerListSpec`, `partnerSheet`/`partnerSheetSpec`, and (gallery only) `partnerObjects` — the exhibition shape's `partnerSpecs.js` never carried an objects-page spec |
 | `useGallerySheet(data, config)` / `useExhibitionSheet(data, config)` | `data`; `config` unused today | `{ itemSheet }`, the `RecordView` spec — the exhibition shape's `citation.project` reads `data.projectName`, absent from the gallery shape |
 | `PAGE_SIZE`, `DATE_MODE`, `FACET_CATEGORIES`, `FACET_LABEL_KEYS`, `useFacetLabels()` | — | the five THG catalogue facets, shared verbatim by both families (nine tiles a page, containment dates, `type`/`dynasty`/`subject`/`material`/`artist`) |
+| `useGalleryItemDetail(data, timeline)` / `useExhibitionItemDetail(data, timeline)` | `data`, the family's `timeline` object; the site's `projectColors` and `noticeProjects` through `useSiteConfig()`, read lazily | `{ itemDetail }`, the item page's `RecordSheetView` spec: the family sheet plus the source-database chip, the Explore-partner notice, the holding-museum link (none for an exhibition's hidden partner), and the related block's labels, outside-reference chips, dynasty popouts and timeline popout. The exhibition gives a record with no project the `mwnf-chip--Explore` chip, and its "search this period" link carries only the timeline controls' keys |
+| `useExhibitionThemes(data)` | `data` | the exhibition's themes: `themeTree` (a `useCollectionTree` over themes.json, `entity: 'themes'`), `themes`, `aboutTheme`, `listedThemes`, `themeByRouteId`/`themeRouteId` (legacy's `display_order - 1`), `romanFor`, `themePictures`, `pictureById`, `themeText`/`pictureText`, `owningTheme`, `subIndexOf`, `pictureParent`, `itemDetailString`, and `useThemePictures(node)`, the live `pictures` `PictureGallery`/`PictureNarrative` read |
+| `buildThemePictures(nodePictures, deps)`, `romanFor(displayOrder)` | — | the pure halves of the above: a node's pictures with their `related`/`backRelated` links resolved across the whole tree, and legacy's Roman theme numeral (display order 2 is "I") |
 
 ### The declaration outside a component
 
@@ -638,6 +641,49 @@ export const { tr, md, mdInline, mdStrip, labelOf, loadEnglish } = catalogue
 | `index(name, key = 'id')` | a `Map` of `entity(name)`'s records by `key` — the visible ones, unlike `byId` |
 | `availableLanguages`, `loadTranslations`, `translations` | the package's own, re-exported so a site reads everything through the one object |
 
+### The catalogue data layer
+
+`useCatalogue` is `useCatalogueData` plus what a catalogue site — a
+standalone product, or a new product scaffolded from `website-template` —
+otherwise re-types for itself: the catalogue entities, their lookups, the
+labels, the routes and the one result row. A site calls it once, in its
+`data.js`, and keeps next to it only what is its own (a scope rule, a
+collection tree, its legacy address mappings).
+
+```js
+import { useCatalogue } from '@museumwnf/viewer-core'
+
+export const data = useCatalogue({
+  eager: ['items', 'countries', 'partners', 'dynasties', 'glossary'],
+  visible: { items: (item) => item.display_status !== 'N' },
+})
+data.loadEnglish()
+
+export const { items, itemRow, countryLabel, tr, md, mdInline } = data
+```
+
+| Export | Meaning |
+| --- | --- |
+| `useCatalogue(options)` | `useCatalogueData(options)`'s own return, plus: `items`, `countries`, `partners`, `dynasties` (the visible records, `null` until loaded); `itemById` (every item, the visible rule not applied — for a page that deliberately shows a hidden one), `partnerById`, `countryById`, `dynastyById`; `itemLabel(item)`, `countryLabel(id)`, `partnerLabel(id)`, `dynastyLabel(id)` (plain text, `''` for nothing); `itemRoute(item)`, `partnerRoute(partner)` (the `item`/`partner` routes by name); `itemRow(item, meta = ['country', 'dates'])` — the row `RecordList`/`RecordGrid`/`RelatedRecords` share, `meta` naming what follows the name in order: `'country'`, `'dates'`, `'location'`, `'dynasties'`, `'holder'` (the partner, only when the package carries it), or a function `(item, text) => string` |
+| `CATALOGUE_PAGE_SIZE`, `CATALOGUE_DATE_MODE` | `20` and `'overlap'`: the standalone pages' size and date rule (decision D5) — named apart from `/dxa`'s `PAGE_SIZE`/`DATE_MODE` (`9`, `'contain'`), which a DXA site imports next to this root |
+| `objectsAndMonumentsSummary({ matching, t })` | legacy's "[N objects, M monuments]", a results spec's `summary` |
+
+The field search of the legacy `database.php` form — keyword rows each
+naming a field, folded with AND/OR — around `useKeywordIndex`'s `fields`
+grammar:
+
+| Export | Meaning |
+| --- | --- |
+| `searchFields({ dynastyLabel })` | the haystack of each field, as legacy's form searched it: `keyword`, `name`, `location`, `provenance`, `patron`, `artist`, `material`, `other`, and `dynasty` when a `dynastyLabel` is given |
+| `searchFieldOptions(fields)` | `[{ key, label }]` (entry names), in legacy's order, for the fields `fields` carries — `SearchFormView`'s `fields` |
+| `useSearchFieldOptions(fields)`, `searchFieldLabel(key, t)` | the same resolved, `[{ value, label }]`, for a select a site draws itself; one field's label |
+| `searchRows(filters, count = 4)`, `searchRowKeys(count = 4)` | the keyword rows the query carries (`q`/`field`, then `qN`/`fieldN`/`opN`), and their query keys for a results spec's `keys` |
+| `searchedFor(filters, t, { rows, extras })`, `searchSummary(ctx, options)` | the "Name: "bowl" · OR Location: "Cairo" · From 900 · Language: FR" line — `extras`, `(filters, t) => string`, append a site's own parts — and the results summary built on it (what was searched, or all items; then the count) |
+| `useFieldSearch({ fields, entity = 'items', rows = 4, rank = 'hits', expand })` | one long-lived index (the glossary and country expansions by default), its search language following the query's `lang`; `narrow(list, filters)` is a results spec's `narrow` — the matches in rank order, kept to the scoped `list`. Pass `sort: false` to the spec. |
+
+`useFeaturedRecord(entity, { filter })` narrows the candidates by a site's
+own visible rule first: it reads the raw entity.
+
 ### Routing
 
 The convention, applied by the router every website shares:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@museumwnf/viewer-core",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Application engine for MWNF websites: turns a dataset.config.js into a mounted Vue application.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE.md",

package/src/catalogue/catalogue.js

@@ -0,0 +1,128 @@
+import { useCatalogueData } from '../composables/useCatalogueData.js'
+import { byId } from '../composables/useEntities.js'
+
+// The catalogue data layer: what a website built on the generic entries —
+// the standalone products, and every new product scaffolded from
+// `website-template` — re-typed around `useCatalogueData` for itself, three
+// times (inventory-app#2037): the entity refs and lookups a catalogue reads,
+// the label and route helpers, the one result row every list shows, the
+// "[N objects, M monuments]" count. A site keeps one instance of it, in its
+// `data.js`, next to what is genuinely its own (a scope rule, a collection
+// tree, its legacy address mappings).
+//
+// The DXA families have their own layer (`@museumwnf/viewer-core/dxa`), over
+// the same `useCatalogueData`; nothing here reads it.
+
+/** Twenty rows a page: the legacy standalone pages' own size. */
+export const CATALOGUE_PAGE_SIZE = 20
+
+/**
+ * The standalone date rule (decision D5): a record overlapping the window
+ * counts, a record with one date is tolerated. The DXA families contain
+ * (`@museumwnf/viewer-core/dxa`'s `DATE_MODE`); a site names its rule once.
+ */
+export const CATALOGUE_DATE_MODE = 'overlap'
+
+/**
+ * The website's catalogue: everything `useCatalogueData` returns, plus the
+ * catalogue entities, their lookups, the labels, the routes and the result
+ * row. Takes `useCatalogueData`'s own options (`eager`, `defaultLanguage`,
+ * `visible`, `glossary`); called once, at the top of the site's `data.js`.
+ *
+ * - `items`, `countries`, `partners`, `dynasties`: the visible records
+ *   (`visible` applies), `null` until loaded.
+ * - `itemById`: every item, the visible rule not applied — a page that
+ *   deliberately shows a hidden item (a timeline's illustration) reads it.
+ *   `partnerById`, `countryById`, `dynastyById`: the visible records.
+ * - `itemLabel(item)`, `countryLabel(id)`, `partnerLabel(id)`,
+ *   `dynastyLabel(id)`: plain text, `''` for nothing.
+ * - `itemRoute(item)`, `partnerRoute(partner)`: the `item` and `partner`
+ *   routes by name.
+ * - `itemRow(item, meta)`: the row `RecordList`/`RecordGrid`/
+ *   `RelatedRecords` share. `meta` lists what follows the name, in order:
+ *   `'country'`, `'dates'`, `'location'`, `'dynasties'`, `'holder'` (the
+ *   partner's name, only when the package carries the partner, so a label
+ *   is never an id), or a function `(item, text) => string`.
+ */
+export function useCatalogue(options = {}) {
+  const data = useCatalogueData(options)
+  const { tr, labelOf, mdInline } = data
+
+  const items = data.entity('items')
+  const countries = data.entity('countries')
+  const partners = data.entity('partners')
+  const dynasties = data.entity('dynasties')
+
+  const itemById = byId('items')
+  const partnerById = data.index('partners')
+  const countryById = data.index('countries')
+  const dynastyById = data.index('dynasties')
+
+  const itemLabel = (item) => (item ? labelOf('items', item.id) : '')
+  const countryLabel = (id) => (id ? labelOf('countries', id) : '')
+  const partnerLabel = (id) => (id ? labelOf('partners', id) : '')
+  const dynastyLabel = (id) => (id ? labelOf('dynasties', id) : '')
+
+  const itemRoute = (item) => ({ name: 'item', params: { id: item.id } })
+  const partnerRoute = (partner) => ({ name: 'partner', params: { id: partner.id } })
+
+  const META = {
+    country: (item) => countryLabel(item.country_id),
+    dates: (item, text) => text.dates,
+    location: (item, text) => text.location,
+    dynasties: (item) => (item.dynasty_ids ?? []).map(dynastyLabel).filter(Boolean).join(', '),
+    holder: (item) => (partnerById.value.has(item.partner_id) ? partnerLabel(item.partner_id) : ''),
+  }
+
+  function itemRow(item, meta = ['country', 'dates']) {
+    const text = tr('items', item.id)
+    return {
+      id: item.id,
+      image: item.images?.[0]?.url ?? '',
+      imageAlt: itemLabel(item),
+      name: mdInline(text.name ?? item.internal_name ?? item.id),
+      meta: meta
+        .map((part) => (typeof part === 'function' ? part(item, text) : META[part]?.(item, text)))
+        .filter(Boolean),
+      badge: item.type ?? '',
+      to: itemRoute(item),
+    }
+  }
+
+  return {
+    ...data,
+    items,
+    countries,
+    partners,
+    dynasties,
+    itemById,
+    partnerById,
+    countryById,
+    dynastyById,
+    itemLabel,
+    countryLabel,
+    partnerLabel,
+    dynastyLabel,
+    itemRoute,
+    partnerRoute,
+    itemRow,
+  }
+}
+
+/**
+ * Legacy's count, "[N objects, M monuments]", over what matched: a results
+ * spec's `summary`. A monument is a record of type `monument`; everything
+ * else counts as an object.
+ */
+export function objectsAndMonumentsSummary({ matching, t }) {
+  let objects = 0
+  let monuments = 0
+  for (const item of matching ?? []) {
+    if (item.type === 'monument') monuments++
+    else objects++
+  }
+  return [
+    { label: t('catalogue.results.objectsFound'), count: objects },
+    { label: t('catalogue.results.monumentsFound'), count: monuments },
+  ]
+}

package/src/catalogue/fieldSearch.js

@@ -0,0 +1,176 @@
+import { computed, ref } from 'vue'
+import { useI18n } from '../i18n/index.js'
+import { combineExpansions, countryExpansion, glossaryExpansion, useKeywordIndex } from './keywordIndex.js'
+
+// The field search of the legacy `database.php` form — keyword rows, each
+// naming a field, folded with AND/OR — which the three standalone products
+// each wired for themselves (inventory-app#2037): the fields' haystacks, the
+// field options and their labels, the rows the query string carries, the
+// "searched for" line, the index. `useKeywordIndex`'s `fields` grammar is
+// the engine; this is the rest of the machinery around it, written once.
+
+/**
+ * What each field of the form searches, field for field as legacy's form
+ * did. `text` is the record's translation in the search language, English
+ * behind it. `keyword` and `location` also carry the record's `country_id`:
+ * `countryExpansion` turns a typed country name into its id, and a field is
+ * only found by that expansion if its haystack carries the id.
+ *
+ * `dynastyLabel(id)` turns on the `dynasty` field — Islamic Art's form has
+ * it, Baroque Art's and Sharing History's do not.
+ */
+export function searchFields({ dynastyLabel } = {}) {
+  const fields = {
+    keyword: (item, text) => [
+      text.name ?? item.internal_name, text.alternate_name, text.description, item.country_id, ...(item.tags ?? []),
+    ],
+    name: (item, text) => text.name ?? item.internal_name,
+    location: (item, text) => [text.location, item.country_id],
+    provenance: (item, text) => text.provenance,
+    patron: (item, text) => text.patrons ?? text.initial_owner,
+    artist: (item, text) => [...(item.artist_names ?? []), text.architects],
+    material: (item, text) => text.type,
+    // The catch-all across the descriptive fields the others leave out.
+    other: (item, text) => [
+      text.description, text.method_for_datation, text.method_for_provenance, text.obtention,
+      text.bibliography, text.workshop, text.scriber, text.binding_desc, text.history,
+    ],
+  }
+  if (dynastyLabel) fields.dynasty = (item) => (item.dynasty_ids ?? []).map(dynastyLabel)
+  return fields
+}
+
+// Every field of the form, in legacy's order, with its entry name.
+const FIELD_OPTIONS = [
+  { key: 'keyword', label: 'catalogue.field.keywords' },
+  { key: 'name', label: 'sheet.field.name' },
+  { key: 'location', label: 'sheet.field.location' },
+  { key: 'provenance', label: 'sheet.field.provenance' },
+  { key: 'dynasty', label: 'catalogue.facet.periodDynasty' },
+  { key: 'patron', label: 'catalogue.field.patron' },
+  { key: 'artist', label: 'catalogue.field.artist' },
+  { key: 'material', label: 'catalogue.field.material' },
+  { key: 'other', label: 'catalogue.field.other' },
+]
+
+/**
+ * The options of the form's field select — `[{ key, label }]`, `label` an
+ * entry name, in legacy's order — for the fields `fields` carries: what
+ * `SearchFormView`'s `fields` takes.
+ */
+export function searchFieldOptions(fields) {
+  return FIELD_OPTIONS.filter((option) => option.key in fields)
+}
+
+/** One field's label, resolved: `key` is what the query string carries. */
+export function searchFieldLabel(key, t) {
+  switch (key) {
+    case 'keyword': return t('catalogue.field.keywords')
+    case 'name': return t('sheet.field.name')
+    case 'location': return t('sheet.field.location')
+    case 'provenance': return t('sheet.field.provenance')
+    case 'dynasty': return t('catalogue.facet.periodDynasty')
+    case 'patron': return t('catalogue.field.patron')
+    case 'artist': return t('catalogue.field.artist')
+    case 'material': return t('catalogue.field.material')
+    case 'other': return t('catalogue.field.other')
+    default: return key
+  }
+}
+
+/**
+ * The same options resolved, `[{ value, label }]`, for a select a site draws
+ * itself — the results page's refine row.
+ */
+export function useSearchFieldOptions(fields) {
+  const { t } = useI18n()
+  return computed(() => searchFieldOptions(fields).map((option) => ({ value: option.key, label: searchFieldLabel(option.key, t) })))
+}
+
+/**
+ * The keyword rows the query string carries: `q`/`field` for the first
+ * (`SearchFormView`'s own, unnumbered), `qN`/`fieldN`/`opN` for the next —
+ * three from the entrance, a fourth for the results page's refine row.
+ * A row with no field searches `keyword`; with no operator, AND.
+ */
+export function searchRows(filters, count = 4) {
+  const rows = []
+  for (let n = 1; n <= count; n++) {
+    rows.push({
+      keyword: n === 1 ? filters.q : filters[`q${n}`],
+      field: (n === 1 ? filters.field : filters[`field${n}`]) || 'keyword',
+      cond: n === 1 ? 'AND' : filters[`op${n}`] || 'AND',
+    })
+  }
+  return rows
+}
+
+/** The query keys `searchRows` reads, for a results spec's `keys`. */
+export function searchRowKeys(count = 4) {
+  const keys = ['q', 'field']
+  for (let n = 2; n <= count; n++) keys.push(`q${n}`, `field${n}`, `op${n}`)
+  return keys
+}
+
+/**
+ * What was searched, spelled out: `Name: "bowl"`, `AND Location: "Cairo"`,
+ * the years, the search language, then the site's own `extras` —
+ * `(filters, t) => string` each, an empty string for nothing. Legacy's
+ * recap line, never just a count, so a visitor who scrolls past the form
+ * still reads what for.
+ */
+export function searchedFor(filters, t, { rows = 4, extras = [] } = {}) {
+  const parts = searchRows(filters, rows)
+    .filter((row) => row.keyword)
+    .map((row, i) => `${i > 0 ? `${row.cond} ` : ''}${searchFieldLabel(row.field, t)}: "${row.keyword}"`)
+  if (filters.from) parts.push(`${t('catalogue.filter.from')} ${filters.from}`)
+  if (filters.to) parts.push(`${t('catalogue.filter.to')} ${filters.to}`)
+  if (filters.lang) parts.push(`${t('catalogue.search.language')}: ${String(filters.lang).toUpperCase()}`)
+  for (const extra of extras) {
+    const part = extra(filters, t)
+    if (part) parts.push(part)
+  }
+  return parts
+}
+
+/**
+ * The results page's summary: what was searched (`searchedFor`), or "all
+ * items" for an empty query, then the count. `options` is `searchedFor`'s.
+ */
+export function searchSummary({ filters, t, pageInfo }, options = {}) {
+  const parts = searchedFor(filters, t, options)
+  return [
+    { label: t('catalogue.search.summary'), value: parts.length ? parts.join(' · ') : t('catalogue.results.allItems') },
+    { label: t('catalogue.results.itemsFound'), count: pageInfo.total },
+  ]
+}
+
+/**
+ * The index behind the results page: one long-lived `useKeywordIndex` over
+ * `entity` (`fields` grammar, legacy's `rank: 'hits'` order, the glossary
+ * and country expansions of `database_results.php`), its search language
+ * kept in step with the query's `lang`. `narrow(list, filters)` is a results
+ * spec's `narrow`: the matches in rank order, kept to what `list` (the
+ * records the spec's `scope` let through) carries. Pass `sort: false` to the
+ * spec, so the rank order stands.
+ */
+export function useFieldSearch({
+  fields,
+  entity = 'items',
+  rows = 4,
+  rank = 'hits',
+  expand = combineExpansions(glossaryExpansion(), countryExpansion()),
+} = {}) {
+  const language = ref('')
+  const index = useKeywordIndex(entity, { grammar: 'fields', fields, language, rank, expand })
+
+  function narrow(list, filters) {
+    language.value = filters.lang || ''
+    const matches = index.search(searchRows(filters, rows))
+    if (!list) return matches
+    const allowed = new Set(list.map((record) => record.id))
+    return matches.filter((record) => allowed.has(record.id))
+  }
+
+  return { narrow, index }
+}

package/src/conventions.js

@@ -108,13 +108,16 @@ function seeded(seed) {
  * among those with an image when `withImage` is set (the default), among
  * all when none has one. Null until the entity is loaded. The pick is made
  * once per visit and again only when the records change; `seed` makes it
- * deterministic.
+ * deterministic. `filter(record)` narrows the candidates first — the site's
+ * own visible rule, since this reads the raw entity (Sharing History's
+ * hidden illustrations, `display_status: 'N'`, must never be picked).
  */
-export function useFeaturedRecord(entity, { withImage = true, seed, images = 'images' } = {}) {
+export function useFeaturedRecord(entity, { withImage = true, seed, images = 'images', filter } = {}) {
   const records = entityRef(entity)
   const random = seed == null ? Math.random : seeded(seed)
   return computed(() => {
-    const all = toValue(records) ?? []
+    const loaded = toValue(records)
+    const all = filter ? (loaded ?? []).filter(filter) : loaded ?? []
     if (all.length === 0) return null
     const pool = withImage ? all.filter((record) => (record?.[images]?.length ?? 0) > 0) : all
     const candidates = pool.length > 0 ? pool : all

package/src/dxa/exhibition/useExhibitionItemDetail.js

@@ -0,0 +1,130 @@
+import { eraLabel, roundOutward } from '../../catalogue/dates.js'
+import { useSiteConfig } from '../../siteConfig.js'
+import { useExhibitionSheet } from './useExhibitionSheet.js'
+
+// An exhibition's item page, as viewer-layout's `RecordSheetView` spec
+// (inventory-app#2053): `useExhibitionSheet`'s field sheet, plus the blocks
+// the view reads through `spec.sourceDatabase`, `spec.notice`, `spec.museum`
+// and `spec.related.*`. The six exhibitions each carried this layer as their
+// own `composables/sheet.js`, the same code in all six.
+//
+// What stays an exhibition's own is read from its `dataset.config.js`
+// through `useSiteConfig()`, lazily, as the galleries do:
+//
+//   * `projectColors`, project id → one of viewer-layout's `mwnf-chip--*`
+//     classes, for the source-database chip and an outside reference's chip;
+//     a record with no project at all is an Explore record, whose chip is
+//     `mwnf-chip--Explore`;
+//   * `noticeProjects`, the projects whose sheets still carry legacy's
+//     Explore-partner notice.
+
+/**
+ * The exhibition's item-page spec, over its data layer's `data` and its
+ * timeline layer's `timeline` (`useExhibitionTimeline`).
+ *
+ * Reads `data.defaultLang`, `data.dynastyById`, `data.isExploreRecord`,
+ * `data.isHiddenPartner`, `data.labelOf`, `data.partnerById`,
+ * `data.partnerRoute`, `data.translations`, what `useExhibitionSheet` reads,
+ * and `timeline.countryIdForCode`, `timeline.findEvents`,
+ * `timeline.hasTimeline`, `timeline.timelineCountries`, `timeline.timelineSpec`.
+ */
+export function useExhibitionItemDetail(data, timeline) {
+  const {
+    defaultLang, dynastyById, isExploreRecord, isHiddenPartner, labelOf, partnerById, partnerRoute, translations,
+  } = data
+  const { countryIdForCode, findEvents, hasTimeline, timelineCountries, timelineSpec } = timeline
+  const { itemSheet: platformSheet } = useExhibitionSheet(data)
+
+  function chipClass(record) {
+    return useSiteConfig().projectColors?.[record.project_id] ?? (isExploreRecord(record) ? 'mwnf-chip--Explore' : null)
+  }
+
+  function dynastyTr(dynasty, language) {
+    return translations('dynasties', language)[dynasty.id] ?? translations('dynasties', defaultLang)[dynasty.id] ?? {}
+  }
+
+  // Legacy popped out a dynasty only when it had a history to show.
+  function dynastiesWithHistory(record, language) {
+    return (record.dynasty_ids ?? [])
+      .map((id) => dynastyById.value.get(id))
+      .filter((d) => d && dynastyTr(d, language).history)
+  }
+
+  // The country the "Timeline for this item" popout opens on: the legacy
+  // two-letter code whose id is the record's own country.
+  function countryCodeOf(countryId) {
+    for (const [code] of timelineCountries.value) {
+      if (countryIdForCode(code) === countryId) return code
+    }
+    return null
+  }
+
+  // The popout's "search this period" link: the timeline results filtered to
+  // the country and the period, under the keys the results page's controls
+  // read — never a key it has no control for (a local timeline has no
+  // country), which it would ignore (inventory-app#2022).
+  function periodSearch(countryCode, range) {
+    const keys = new Set((timelineSpec.value?.controls ?? []).map((control) => control.key))
+    const query = { country: countryCode, begin: range[0], end: range[1] }
+    return { name: 'timeline-results', query: Object.fromEntries(Object.entries(query).filter(([key]) => keys.has(key))) }
+  }
+
+  const itemDetail = {
+    ...platformSheet,
+
+    sourceDatabase: {
+      chipClass: (record) => chipClass(record),
+    },
+
+    notice: {
+      show: (record) => (useSiteConfig().noticeProjects ?? []).includes(record.project_id),
+      label: 'exhibition.item.explorePartnerNote',
+    },
+
+    // A hidden museum keeps its name on the sheet and loses the link: it has
+    // no page to link to.
+    museum: {
+      route: (partnerId) => {
+        const partner = partnerById.value.get(partnerId)
+        if (!partner || isHiddenPartner(partner)) return null
+        return partnerRoute(partner)
+      },
+      label: (partnerId) => labelOf('partners', partnerId),
+    },
+
+    related: {
+      ...platformSheet.related,
+      title: 'exhibition.related.title',
+      description: 'exhibition.related.description',
+      outsideChip: (ref) => chipClass(ref),
+      notInPackageLabel: 'exhibition.results.notInThisExhibition',
+      artisticIntroductionLabel: 'exhibition.nav.artisticIntroduction',
+      databaseLabel: 'exhibition.search.relatedDatabase',
+      overallDatabase: { label: 'exhibition.search.overallDatabase', linkLabel: 'exhibition.nav.overallDatabase' },
+      onDisplayIn: { linkPendingLabel: 'exhibition.item.linkPending' },
+      dynasties: (record, language) => ({
+        records: dynastiesWithHistory(record, language),
+        tr: (d) => dynastyTr(d, language),
+      }),
+      // Withheld when the exhibition reports no chronology, or the item has
+      // no date to anchor a range on: legacy then printed no "timeline"
+      // anywhere on the sheet.
+      timeline: (record, ctx) => {
+        if (!hasTimeline.value) return null
+        const range = roundOutward(record.start_date, record.end_date)
+        if (range[0] == null) return null
+        return {
+          heading: 'exhibition.section.timeline',
+          countries: timelineCountries.value.map(([value, label]) => ({ value, label })),
+          defaultCountry: () => countryCodeOf(record.country_id) ?? 'all',
+          events: (countryCode) => findEvents({ countryCode, start: range[0], end: range[1] }),
+          range,
+          era: (year) => eraLabel(year, ctx.t),
+          searchTo: periodSearch,
+        }
+      },
+    },
+  }
+
+  return { itemDetail }
+}

package/src/dxa/exhibition/useExhibitionThemes.js

@@ -0,0 +1,279 @@
+import { computed } from 'vue'
+import { useI18n } from '../../i18n/index.js'
+import { entityRef } from '../../composables/useEntities.js'
+import { useCollectionTree } from '../../record/collectionTree.js'
+
+// An exhibition's themes: the tour its theme pages, its themes list and its
+// theme galleries read (inventory-app#2053). The six exhibitions each carried
+// this as `composables/themes.js`, `useThemePresentation.js` and
+// `useThemePictures.js`, the same code in all six.
+//
+// themes.json is the ordered tree: top-level themes, each with its sub-themes
+// and its curated picture selections. `useCollectionTree({ source: 'themes' })`
+// walks it, and its `previous`/`next` (depth-first) is legacy's tour order:
+// About → theme 1 overview → its sub-themes → theme 2 overview → ….
+//
+// Two rules the data fixes rather than taste:
+//
+//   * Theme 0 ("About the Exhibition") is an ordinary top-level theme legacy
+//     renders at /about and skips on /themes. Its display order is 1, so the
+//     themes list starts at display order 2 and numbers those "Theme I"
+//     upwards — which is why `romanFor` subtracts one.
+//   * The theme id in the keyspace is not the display order. The route
+//     carries `display_order - 1`, as legacy's `theme.display - 1` did, so a
+//     legacy address pasted after the `#` lands on the same theme.
+//
+// A theme's selections point at `picture` items, which are not members of the
+// exhibition and so not in items.json — only their parents are. Every label a
+// theme page shows (name, holding museum, location, country) is read off the
+// parent record, which is also what "see the full record" links to.
+// `parent_in_package` says whether the parent is there at all: a curated
+// picture whose parent was not exported still renders its own image.
+
+/**
+ * Legacy numbered its themes in Roman numerals, counting from the About
+ * theme. EssayView's `numbering: 'roman'` counts a node's position among its
+ * siblings, which it derives from `tree.root` — always null for a themes.json
+ * package — so it would number every top-level theme "I". The numeral an
+ * exhibition shows is always the owning theme's, so one function serves
+ * themes and sub-themes.
+ */
+export function romanFor(displayOrder) {
+  const lookup = [
+    ['M', 1000], ['CM', 900], ['D', 500], ['CD', 400], ['C', 100], ['XC', 90],
+    ['L', 50], ['XL', 40], ['X', 10], ['IX', 9], ['V', 5], ['IV', 4], ['I', 1],
+  ]
+  let n = displayOrder - 1
+  let out = ''
+  for (const [sym, value] of lookup) {
+    while (n >= value) { out += sym; n -= value }
+  }
+  return out
+}
+
+/**
+ * The `pictures` PictureGallery/PictureNarrative read (viewer-layout's
+ * docs/theme-components.md) for one node, as a pure function of its data so
+ * the graph rules are tested without Vue or a package.
+ *
+ * A picture's `related`/`backRelated` targets resolve against `pictureById`,
+ * the WHOLE tree's picture index, not the node's own selections:
+ * `theme_item_related` rows can name a picture curated under another theme,
+ * and scoping the lookup to the node is what used to drop such a link.
+ *
+ * @param nodePictures - the node's own selections, in curator order
+ * @param deps.pictureById - Map<pictureId, rawPicture> for every picture in the tree
+ * @param deps.resolvePicture - (raw) => `{ id, image, imageAlt, name, detail, to }`,
+ *   the node-independent shape, used for the node's pictures and every target
+ * @param deps.imageCaptionFor - (raw) => this node's own caption for the picture
+ * @param deps.fieldsFor - (raw) => this node's panel `fields` for the picture
+ * @param deps.relationText - (link) => the forward relation's text
+ * @param deps.reciprocalText - (link) => the backward relation's text
+ */
+export function buildThemePictures(nodePictures, deps) {
+  const {
+    pictureById: byId, resolvePicture, imageCaptionFor, fieldsFor, relationText, reciprocalText,
+  } = deps
+
+  return (nodePictures ?? []).map((raw) => {
+    const related = (raw.related ?? [])
+      .map((link) => {
+        const target = byId.get(link.picture_item_id)
+        return target ? { picture: resolvePicture(target), text: relationText(link) } : null
+      })
+      .filter(Boolean)
+
+    // Every other picture anywhere in the tree whose own `related` names this
+    // one, so a target on another theme's page still shows "related to" back.
+    const backRelated = []
+    for (const other of byId.values()) {
+      for (const link of other.related ?? []) {
+        if (link.picture_item_id === raw.picture_item_id) {
+          backRelated.push({ picture: resolvePicture(other), reciprocalText: reciprocalText(link) })
+        }
+      }
+    }
+
+    return {
+      ...resolvePicture(raw),
+      imageCaption: imageCaptionFor(raw),
+      fields: fieldsFor(raw),
+      // Not part of the components' contract: the theme page turns a
+      // selection back into legacy's `?image=<display_order>` with it.
+      displayOrder: raw.display_order,
+      related,
+      backRelated,
+    }
+  })
+}
+
+/**
+ * The exhibition's themes, over its data layer's `data`.
+ *
+ * Reads `data.defaultLang`, `data.itemById`, `data.itemRoute`, `data.labelOf`,
+ * `data.mdInline`, `data.tr`.
+ */
+export function useExhibitionThemes(data) {
+  const { defaultLang, itemById, itemRoute, labelOf, mdInline, tr } = data
+
+  // EssayView reads `spec.tree.entity` to know where a node's own text lives,
+  // even for a tree built here rather than from its `{ themes: true }`
+  // shorthand; without it, every title/quote/body lookup would read
+  // 'collections', not a themes.json package's entity.
+  const themeTree = useCollectionTree({ source: 'themes', entity: 'themes' })
+  themeTree.entity = 'themes'
+
+  // The raw top-level array, in the order the themes list and the tour read
+  // them: the tree's own `root` is always null for this shape, so it cannot
+  // hand back every top-level theme itself.
+  const rawThemes = entityRef('themes')
+  const themes = computed(() => rawThemes.value ?? [])
+
+  const aboutTheme = computed(() => themes.value.find((t) => t.display_order === 1) ?? null)
+
+  /** The themes the themes page lists: everything after the About theme. */
+  const listedThemes = computed(() => themes.value.filter((t) => t.display_order > 1))
+
+  /** Route id → theme: legacy's `/theme/:id` carries `display_order - 1`. */
+  function themeByRouteId(id) {
+    const n = Number(id)
+    return themes.value.find((t) => t.display_order - 1 === n) ?? null
+  }
+
+  function themeRouteId(theme) {
+    return (theme?.display_order ?? 1) - 1
+  }
+
+  /** A node's picture selections, in curator order. */
+  function themePictures(theme) {
+    return [...(theme?.pictures ?? [])].sort((a, b) => (a.display_order ?? 0) - (b.display_order ?? 0))
+  }
+
+  /** Every picture selection in the tree, by its own id (not a catalogue id). */
+  const pictureById = computed(() => {
+    const map = new Map()
+    for (const node of themeTree.byId.value.values()) {
+      for (const picture of node.pictures ?? []) map.set(picture.picture_item_id, picture)
+    }
+    return map
+  })
+
+  // translations/themes.<lang>.json is keyed two ways: by theme id for the
+  // theme's own title/quote/presentation, and by `<theme id>/<picture item
+  // id>` for one picture's curated text in that theme — the same picture in
+  // two themes carries two descriptions.
+  function themeText(theme, lang = defaultLang) {
+    return tr('themes', theme?.id, lang)
+  }
+
+  function pictureText(theme, picture, lang = defaultLang) {
+    if (!theme?.id || !picture?.picture_item_id) return {}
+    return tr('themes', `${theme.id}/${picture.picture_item_id}`, lang)
+  }
+
+  /** The top-level theme that owns a node: the node itself, or its parent. */
+  function owningTheme(node) {
+    if (!node) return null
+    const parents = themeTree.parents(node.id)
+    return parents.length ? parents[0] : node
+  }
+
+  /** A node's 1-based position among its owning theme's sub-themes; null for the theme itself. */
+  function subIndexOf(node) {
+    if (!node) return null
+    const owner = owningTheme(node)
+    if (!owner || owner.id === node.id) return null
+    const index = themeTree.children(owner.id).findIndex((child) => child.id === node.id)
+    return index === -1 ? null : index + 1
+  }
+
+  /** A picture selection's parent record, or null when it is not a member. */
+  function pictureParent(picture) {
+    if (!picture?.parent_in_package) return null
+    return itemById.value.get(picture.parent_item_id) ?? null
+  }
+
+  /** Legacy's `itemDetailString`: museum, location, country, blanks dropped. */
+  function itemDetailString(item) {
+    if (!item) return ''
+    const sheet = tr('items', item.id, defaultLang)
+    return [
+      sheet.holder || labelOf('partners', item.partner_id),
+      sheet.location,
+      labelOf('countries', item.country_id),
+    ].filter(Boolean).join(', ')
+  }
+
+  /**
+   * A node's `pictures`, live: its selections resolved against the parent
+   * records, the translations and the current locale. Call it in a
+   * component's setup; `node` is a ref.
+   */
+  function useThemePictures(node) {
+    const { t, locale } = useI18n()
+
+    function resolvePicture(raw) {
+      const parent = pictureParent(raw)
+      const name = parent ? labelOf('items', parent.id) : ''
+      return {
+        id: raw.picture_item_id,
+        image: raw.image_url,
+        imageAlt: name,
+        name: mdInline(name),
+        detail: itemDetailString(parent),
+        to: parent ? itemRoute(parent) : null,
+      }
+    }
+
+    function imageCaptionFor(raw) {
+      if (!node.value?.id) return ''
+      return tr('themes', `${node.value.id}/${raw.picture_item_id}`, locale.value).image_caption ?? ''
+    }
+
+    // Legacy labelled only "also known as"; artist names and dates stand
+    // alone, as `fields` rows with an empty label.
+    function fieldsFor(raw) {
+      const parent = pictureParent(raw)
+      if (!parent) return []
+      const sheet = tr('items', parent.id, defaultLang)
+      const fields = []
+      if (sheet.alternate_name) {
+        fields.push({ label: `${t('sheet.field.alsoKnownAs')}:`, value: mdInline(sheet.alternate_name) })
+      }
+      if (parent.artist_names?.length) fields.push({ label: '', value: parent.artist_names.join(', ') })
+      if (sheet.dates) fields.push({ label: '', value: sheet.dates })
+      return fields
+    }
+
+    const relationText = (link) => link?.descriptions?.[locale.value] ?? link?.descriptions?.en ?? ''
+    const reciprocalText = (link) => link?.reciprocal_descriptions?.[locale.value] ?? link?.reciprocal_descriptions?.en ?? ''
+
+    return computed(() => buildThemePictures(themePictures(node.value), {
+      pictureById: pictureById.value,
+      resolvePicture,
+      imageCaptionFor,
+      fieldsFor,
+      relationText,
+      reciprocalText,
+    }))
+  }
+
+  return {
+    themeTree,
+    themes,
+    aboutTheme,
+    listedThemes,
+    themeByRouteId,
+    themeRouteId,
+    romanFor,
+    themePictures,
+    pictureById,
+    themeText,
+    pictureText,
+    owningTheme,
+    subIndexOf,
+    pictureParent,
+    itemDetailString,
+    useThemePictures,
+  }
+}

package/src/dxa/gallery/useGalleryItemDetail.js

@@ -0,0 +1,110 @@
+import { eraLabel, roundOutward } from '../../catalogue/dates.js'
+import { useSiteConfig } from '../../siteConfig.js'
+import { useGallerySheet } from './useGallerySheet.js'
+
+// A gallery's item page, as viewer-layout's `RecordSheetView` spec
+// (inventory-app#2054): `useGallerySheet`'s field sheet, plus the blocks the
+// view reads through `spec.sourceDatabase`, `spec.notice`, `spec.museum` and
+// `spec.related.*` — the project chips, the Explore-partner notice, the
+// holding-museum link, and the related block's outside references,
+// cross-database links, dynasty popouts and timeline popout. The 37
+// galleries each carried this layer in their own `composables/gallery.js`,
+// the same code in all 37.
+//
+// What stays a gallery's own is read from its `dataset.config.js` through
+// `useSiteConfig()`, lazily, inside the functions the view calls at render
+// time — `dataset.config.js` is imported before `createViewer()` sets the
+// config, so a read at module level would only ever see the empty default:
+//
+//   * `projectColors`, project id → one of viewer-layout's `mwnf-chip--*`
+//     classes, for the source-database chip and an outside reference's chip;
+//   * `noticeProjects`, the projects whose sheets still carry legacy's
+//     Explore-partner notice.
+
+/**
+ * The gallery's item-page spec, over its data layer's `data` and its
+ * timeline layer's `timeline` (`useGalleryTimeline`).
+ *
+ * Reads `data.defaultLang`, `data.dynastyById`, `data.labelOf`,
+ * `data.partnerById`, `data.partnerRoute`, `data.translations`, what
+ * `useGallerySheet` reads, and `timeline.countryIdForCode`,
+ * `timeline.timelineEvents` (`countries`, `findEvents`).
+ */
+export function useGalleryItemDetail(data, timeline) {
+  const { defaultLang, dynastyById, labelOf, partnerById, partnerRoute, translations } = data
+  const { countryIdForCode, timelineEvents } = timeline
+  const { countries: timelineCountries, findEvents } = timelineEvents
+  const { itemSheet: platformSheet } = useGallerySheet(data)
+
+  const chipClass = (record) => useSiteConfig().projectColors?.[record.project_id] ?? null
+
+  function museumRoute(partnerId) {
+    const partner = partnerById.value.get(partnerId)
+    return partner ? partnerRoute(partner) : null
+  }
+
+  function dynastyTranslation(dynasty, language) {
+    return translations('dynasties', language)[dynasty.id] ?? translations('dynasties', defaultLang)[dynasty.id] ?? {}
+  }
+
+  // Legacy popped out a dynasty only when it had a history to show.
+  function itemDynasties(record, language) {
+    const records = (record.dynasty_ids ?? [])
+      .map((id) => dynastyById.value.get(id))
+      .filter((d) => d && dynastyTranslation(d, language).history)
+    return records.length ? { records, tr: (d) => dynastyTranslation(d, language) } : null
+  }
+
+  // The timeline popout, for the record's own date range: the gallery's own
+  // countries, events and search route.
+  function itemTimeline(record, ctx) {
+    const [from, to] = roundOutward(record.start_date, record.end_date)
+    if (from == null) return null
+    return {
+      heading: 'gallery.section.timeline',
+      countries: timelineCountries.value.map((c) => ({ value: c.value, label: c.label ?? ctx.t('timeline.form.allCountries') })),
+      defaultCountry: () => {
+        for (const { value: code } of timelineCountries.value) {
+          if (countryIdForCode(code) === record.country_id) return code
+        }
+        return 'all'
+      },
+      events: (country) => findEvents({ country, begin: from, end: to }),
+      range: [from, to],
+      era: (year) => eraLabel(year, ctx.t),
+      searchTo: (country, [begin, end]) => ({ name: 'timeline-results', query: { country, begin, end } }),
+    }
+  }
+
+  const itemDetail = {
+    ...platformSheet,
+    sourceDatabase: {
+      chipClass,
+    },
+    notice: {
+      show: (record) => (useSiteConfig().noticeProjects ?? []).includes(record.project_id),
+      label: 'gallery.item.explorePartnerNote',
+    },
+    museum: {
+      route: (partnerId) => museumRoute(partnerId),
+      label: (partnerId) => labelOf('partners', partnerId),
+    },
+    related: {
+      ...platformSheet.related,
+      title: 'gallery.related.title',
+      description: 'gallery.related.description',
+      notInPackageLabel: 'gallery.results.notInThisGallery',
+      // An outside `related_items` reference carries its `project_id`
+      // (inventory-app#1807), so it reads the same `projectColors` map.
+      outsideChip: chipClass,
+      artisticIntroductionLabel: 'gallery.nav.artisticIntroduction',
+      databaseLabel: 'gallery.search.relatedDatabase',
+      overallDatabase: { label: 'gallery.search.overallDatabase', linkLabel: 'gallery.nav.overallDatabase' },
+      onDisplayIn: { linkPendingLabel: 'gallery.item.linkPending' },
+      dynasties: (record, language) => itemDynasties(record, language),
+      timeline: itemTimeline,
+    },
+  }
+
+  return { itemDetail }
+}

package/src/dxa/index.js

@@ -26,9 +26,12 @@ export { useGalleryCollection } from './gallery/useGalleryCollection.js'
 export { useGalleryTimeline } from './gallery/useGalleryTimeline.js'
 export { useGalleryPartner } from './gallery/useGalleryPartner.js'
 export { useGallerySheet } from './gallery/useGallerySheet.js'
+export { useGalleryItemDetail } from './gallery/useGalleryItemDetail.js'
 
 export { useExhibitionData } from './exhibition/useExhibitionData.js'
 export { useExhibitionCollection } from './exhibition/useExhibitionCollection.js'
 export { useExhibitionTimeline } from './exhibition/useExhibitionTimeline.js'
 export { useExhibitionPartner } from './exhibition/useExhibitionPartner.js'
 export { useExhibitionSheet } from './exhibition/useExhibitionSheet.js'
+export { useExhibitionItemDetail } from './exhibition/useExhibitionItemDetail.js'
+export { buildThemePictures, romanFor, useExhibitionThemes } from './exhibition/useExhibitionThemes.js'

package/src/index.js

@@ -1,6 +1,13 @@
 export { createViewer } from './createViewer.js'
 export { createStandardViewer } from './createStandardViewer.js'
 export { useCatalogueData } from './composables/useCatalogueData.js'
+export {
+  CATALOGUE_DATE_MODE, CATALOGUE_PAGE_SIZE, objectsAndMonumentsSummary, useCatalogue,
+} from './catalogue/catalogue.js'
+export {
+  searchFieldLabel, searchFieldOptions, searchFields, searchRowKeys, searchRows, searchSummary, searchedFor,
+  useFieldSearch, useSearchFieldOptions,
+} from './catalogue/fieldSearch.js'
 export { useDataPackage } from './composables/useDataPackage.js'
 export { byId, entityRef, loadEntities, useEntities } from './composables/useEntities.js'
 export { resolveRecordLanguage, useRecordLanguage } from './composables/useRecordLanguage.js'

package/src/record/partners.js

@@ -118,14 +118,10 @@ const byDisplayOrder = (a, b) => (a?.display_order ?? 0) - (b?.display_order ??
 
 /**
  * The contact persons in legacy order (person 1 first), keeping only those
- * with a name or a title — legacy printed a person block only then. Reads
- * `contact_persons`; a package built before that list existed carries
- * `contact_person_1`/`_2` instead (inventory-app#2007 removes them).
+ * with a name or a title — legacy printed a person block only then.
  */
 function contactPersons(partner) {
-  const list = Array.isArray(partner?.contact_persons)
-    ? partner.contact_persons
-    : [partner?.contact_person_1, partner?.contact_person_2]
+  const list = Array.isArray(partner?.contact_persons) ? partner.contact_persons : []
   return list
     .filter((person) => person && (person.name || person.title))
     .map((person) => ({