@museumwnf/viewer-core 1.15.1 → 1.16.1

package/src/dxa/gallery/useGalleryData.js

@@ -0,0 +1,143 @@
+import { computed } from 'vue'
+import { mediaUrl } from '../../siteConfig.js'
+import { useCatalogueData } from '../../composables/useCatalogueData.js'
+import { useDataPackage } from '../../composables/useDataPackage.js'
+import { itemFromUidPath as legacyItemFromUidPath, partnerFromKey as legacyPartnerFromKey } from '../../legacy/index.js'
+
+// The data layer every DXA gallery site (carpets, amulets, …) wrote for
+// itself: the entities a gallery reads, the lookup maps over them, its
+// routes, its legacy URL mappings and its chrome. Promoted from the
+// byte-identical copies the two live galleries carried (epic #1730) — what a
+// future gallery needs that is genuinely its own belongs in `config`, not in
+// a fork of this file.
+
+/** Every entity a gallery page reads English labels or fallbacks for. */
+const DEFAULT_EAGER = ['items', 'partners', 'countries', 'glossary', 'dynasties', 'timeline_events']
+
+/**
+ * The gallery's data layer, bound to the installed data package.
+ *
+ * `config.eager` overrides the entities `loadEnglish` loads eagerly
+ * (default: {@link DEFAULT_EAGER}) — a future gallery whose package carries
+ * extra entities of its own passes a longer list.
+ */
+export function useGalleryData(config = {}) {
+  const dataPackage = useDataPackage()
+  const manifest = dataPackage.manifest
+
+  const catalogue = useCatalogueData({
+    eager: config.eager ?? DEFAULT_EAGER,
+  })
+
+  const {
+    tr, md, mdInline, mdStrip, loadEnglish, labelOf,
+    availableLanguages, loadTranslations, translations,
+  } = catalogue
+
+  // English is the base language of every catalogue in the platform: every
+  // list, label and fallback reads it.
+  const defaultLang = 'en'
+
+  // ── Records ────────────────────────────────────────────────────────────
+  // Language-independent; every human-readable string lives under translations/.
+
+  const gallery = catalogue.entity('gallery')
+  const items = catalogue.entity('items')
+  const tags = catalogue.entity('tags')
+  const partners = catalogue.entity('partners')
+  const countries = catalogue.entity('countries')
+  const languages = catalogue.entity('languages')
+  const dynasties = catalogue.entity('dynasties')
+  const glossary = catalogue.entity('glossary')
+  const timelines = catalogue.entity('timelines')
+  const timelineEvents = catalogue.entity('timeline_events')
+
+  // ── Lookup maps ────────────────────────────────────────────────────────
+
+  const itemById = catalogue.index('items')
+  const partnerById = catalogue.index('partners')
+  const countryById = catalogue.index('countries')
+  const tagById = catalogue.index('tags')
+  const dynastyById = catalogue.index('dynasties')
+  const timelineById = catalogue.index('timelines')
+  const languageByCode = catalogue.index('languages', 'code')
+
+  // ── Routes ─────────────────────────────────────────────────────────────
+  //
+  // The canonical routes carry the package id; the language never travels
+  // in the path. The legacy shapes (the dbUid path of an item sheet, the
+  // country and legacy id of a partner) are redirect-only entries in the
+  // site's own `dataset.config.js`, resolved through the two wrappers below.
+
+  function itemRoute(item) {
+    return { name: 'item', params: { id: item.id } }
+  }
+
+  function partnerRoute(partner) {
+    return { name: 'partner', params: { id: partner.id } }
+  }
+
+  function partnerObjectsRoute(partner, page = 1) {
+    return { name: 'partner-objects', params: { id: partner.id }, query: page > 1 ? { page } : {} }
+  }
+
+  // Legacy dbUid ⇄ item, and a partner's country/legacy id ⇄ partner: the
+  // `legacy` entry point decodes `backward_compatibility` the way every DXA
+  // site does, pure, over plain lists; these two wrappers bind it to this
+  // gallery's own `items`/`partners`/`countries` refs, so the site's legacy
+  // routes keep calling them with the arguments they already carry.
+  function itemFromUidPath(path) {
+    return legacyItemFromUidPath(items.value ?? [], path)
+  }
+
+  function partnerFromKey(countryCode, legacyId) {
+    return legacyPartnerFromKey(partners.value ?? [], countries.value ?? [], countryCode, legacyId)
+  }
+
+  // ── Chrome images ──────────────────────────────────────────────────────
+  //
+  // `image_path`, `banner_image_path` and `homepage_image_path` were never
+  // imported into inventory storage: the package ships the legacy path and
+  // the address is built from the host the site's `dataset.config.js`
+  // declares under `media`.
+
+  function chromeImage(path, size = 'hi_res') {
+    return mediaUrl(path, size)
+  }
+
+  // ── Sibling galleries ──────────────────────────────────────────────────
+  //
+  // Decision Q3: these are reference objects, not resolved links. The
+  // exporter records identity plus whatever the import carried; where a
+  // `legacy_host` came across we can link to it, and where it did not the
+  // entry still renders — it just does not become an anchor.
+
+  const siblingGalleries = computed(() =>
+    (gallery.value?.sibling_galleries ?? []).filter((g) => !g.hidden),
+  )
+
+  function siblingUrl(sibling) {
+    return sibling?.legacy_host || null
+  }
+
+  /** Four at random, reshuffled per visit. */
+  function pickSiblings(count = 4) {
+    const pool = [...siblingGalleries.value]
+    for (let i = pool.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1))
+      ;[pool[i], pool[j]] = [pool[j], pool[i]]
+    }
+    return pool.slice(0, count)
+  }
+
+  return {
+    manifest,
+    defaultLang,
+    tr, md, mdInline, mdStrip, loadEnglish, labelOf,
+    availableLanguages, loadTranslations, translations,
+    gallery, items, tags, partners, countries, languages, dynasties, glossary, timelines, timelineEvents,
+    itemById, partnerById, countryById, tagById, dynastyById, timelineById, languageByCode,
+    itemRoute, partnerRoute, partnerObjectsRoute, itemFromUidPath, partnerFromKey,
+    chromeImage, siblingGalleries, siblingUrl, pickSiblings,
+  }
+}

package/src/dxa/gallery/useGalleryPartner.js

@@ -0,0 +1,77 @@
+import { PAGE_SIZE } from '../shared.js'
+
+// The partner pages, as specs: what viewer-layout's `PartnerListView`,
+// `RecordView` and `CatalogueResultsView` render on `/partners`,
+// `/partner/:id` and `/partner/:id/objects`. The grouping, the A–Z toggle,
+// the record's language and the pagination are the platform's; what is
+// declared here is only what is a gallery's: DXA's own list shape (no
+// tiers), the country label, and the object grid's tile.
+
+/**
+ * The gallery's partner specs, over its data layer's `data` and the
+ * `PAGE_SIZE`/`tile` its {@link import('./useGalleryCollection.js').useGalleryCollection}
+ * already declared.
+ *
+ * Reads `data.labelOf`. `config` carries nothing today.
+ */
+export function useGalleryPartner(data, collection, config = {}) {
+  void config
+  const { labelOf } = data
+  const { tile } = collection
+
+  // ── The list ───────────────────────────────────────────────────────────
+  //
+  // DXA's own shape, per the package README: no main/associated tiers
+  // (every partner is a flat row), grouped by country, with the A–Z / Z–A
+  // toggle legacy showed. `route` is a string, so the platform builds each
+  // row's link itself; the "View objects" link and the "no objects" line
+  // are the site's own `#row` concern in Partners.vue — decision MWNF-384:
+  // a partner created under a gallery's own project is listed even when it
+  // holds no member item, and only that link is withheld.
+  const partnerList = {
+    group: { tier: false, order: 'country' },
+    variant: 'open',
+    orderToggle: true,
+    route: 'partner',
+    label: (countryId) => labelOf('countries', countryId),
+  }
+
+  // ── The profile ────────────────────────────────────────────────────────
+  //
+  // Legacy's partner page is a tab strip (About/Contact/Logo/homepage),
+  // never a table of labelled fields, so `fields` stays empty —
+  // PartnerProfile.vue fills `header` and `before-sheet` with the tabs
+  // instead — and the sections a sheet carries by default (credits,
+  // citation, related records) are switched off: legacy printed none of
+  // them on this page.
+  const partnerSheet = {
+    entity: 'partners',
+    fields: [],
+    credits: [],
+    citation: false,
+    related: false,
+    route: 'partner',
+  }
+
+  // ── The objects page ──────────────────────────────────────────────────
+  //
+  // The member items one partner holds, on the same grid the collection
+  // results and the timeline gallery use. `scope` is built per-page in the
+  // site's own PartnerObjects.vue, over the route's own id —
+  // `CatalogueResultsView` takes no record id of its own, unlike
+  // `RecordView`.
+  const partnerObjects = {
+    entity: 'items',
+    sort: { undated: 'first' },
+    pageSize: PAGE_SIZE,
+    variant: 'grid',
+    recordRoute: 'item',
+    actionLabel: 'gallery.action.seeDatabaseEntry',
+    empty: 'gallery.partner.noObjects',
+    pagination: { jump: true },
+    record: (item, { t }) => tile(item, t),
+    summary: ({ pageInfo, t }) => [{ count: pageInfo.total, value: t('partner.item.objectsInSite') }],
+  }
+
+  return { partnerList, partnerSheet, partnerObjects }
+}

package/src/dxa/gallery/useGallerySheet.js

@@ -0,0 +1,118 @@
+// The item sheet, as a spec: what viewer-layout's `RecordView` renders on
+// `/item/:id`. The mechanics — which language the record is read in, what
+// is loaded for it, the glossary terms it reaches, how a field becomes a
+// row, the credits, the citation, the related records — are the platform's.
+// What is declared here is only what is a gallery's: the field
+// specification (legacy DatabaseItem.vue's `objectData`, field for field),
+// the photos in their order, the related tile, and the citation without a
+// permalink, as legacy printed it. Every label is an entry name, written
+// out so the check that every name resolves can read it.
+//
+// Order and labels are the legacy sheet's. Empty values are dropped by the
+// engine, as legacy's `filterData` did. `notice` and `notice_c` were never
+// imported; `notice_b` is the image rights statement, imported as
+// `extra.copyright` and rendered as the last row, where legacy put its own
+// block. The labels are in the language the visitor reads the website in —
+// where it differs from the record's (a deep link into a borrowed record in
+// a language a gallery does not offer) they fall back to English, which is
+// where legacy pinned them anyway.
+//
+// Legacy shows both descriptions when both exist, with the short one
+// collapsed behind a toggle (the view's, folded after the description);
+// when only one exists it is relabelled plain "Description". EPM records
+// are the common case of the latter.
+
+/**
+ * The gallery's item-sheet spec, over its data layer's `data`.
+ *
+ * Reads `data.defaultLang`, `data.itemRoute`, `data.labelOf`,
+ * `data.mdInline`, `data.mdStrip`, `data.partnerById`, `data.tr`,
+ * `data.translations`. `config` carries nothing today.
+ */
+export function useGallerySheet(data, config = {}) {
+  void config
+  const { defaultLang, itemRoute, labelOf, mdInline, mdStrip, partnerById, tr, translations } = data
+
+  const bothDescriptions = (c) => Boolean(c.text.description) && Boolean(c.text.short_description)
+
+  const dynastyNames = (c) =>
+    (c.record.dynasty_ids ?? [])
+      .map((id) => translations('dynasties', c.language)[id]?.name ?? translations('dynasties', defaultLang)[id]?.name ?? '')
+      .filter(Boolean)
+      .join(', ')
+
+  const fields = [
+    { key: 'name', label: 'sheet.field.name', value: 'name' },
+    { key: 'aka', label: 'sheet.field.alsoKnownAs', value: 'alternate_name' },
+    { key: 'location', label: 'sheet.field.location', value: (c) => [c.text.location, labelOf('countries', c.record.country_id)].filter(Boolean).join(', ') },
+    // A link to the partner's page, rendered by the wrapper's `museum` slot.
+    { key: 'museum', label: 'sheet.field.holdingMuseum', value: (c) => (partnerById.value.get(c.record.partner_id) ? c.record.partner_id : ''), render: 'custom' },
+    { key: 'originalOwner', label: 'sheet.field.originalOwner', value: 'initial_owner' },
+    { key: 'currentOwner', label: 'sheet.field.currentOwner', value: 'owner' },
+    { key: 'date', label: 'sheet.field.date', value: 'dates' },
+    { key: 'artist', label: 'sheet.field.artists', value: (c) => c.record.artist_names, join: ', ' },
+    { key: 'scribe', label: 'sheet.field.scribe', value: 'scriber' },
+    { key: 'workshop', label: 'sheet.field.workshop', value: 'workshop' },
+    { key: 'type', label: 'sheet.field.type', value: 'type' },
+    { key: 'inventoryNumber', label: 'sheet.field.inventoryNumber', value: (c) => c.record.owner_reference },
+    { key: 'materials', label: 'sheet.field.materials', value: (c) => c.text.materials, join: '; ' },
+    { key: 'dimensions', label: 'sheet.field.dimensions', value: 'dimensions' },
+    { key: 'dynasty', label: 'sheet.field.periodDynasty', value: dynastyNames },
+    { key: 'production', label: 'sheet.field.placeOfProduction', value: 'place_of_production' },
+    { key: 'provenance', label: 'sheet.field.provenance', value: 'provenance' },
+    { key: 'binding', label: 'sheet.field.binding', value: 'binding_desc' },
+    { key: 'description', label: 'sheet.field.description', value: 'description', render: 'block' },
+    // The only description there is, under the plain label; the toggled one
+    // is the view's, folded after `description` when both exist.
+    { key: 'shortDescription', label: 'sheet.field.description', value: 'short_description', render: 'block', when: (c) => !bothDescriptions(c) },
+    { key: 'catalogue', label: 'sheet.field.catalogueLink', value: 'linkcatalogs', render: 'link' },
+    { key: 'obtention', label: 'sheet.field.obtentionMethod', value: 'obtention' },
+    { key: 'datation', label: 'sheet.field.datationMethod', value: 'method_for_datation' },
+    { key: 'provenanceMethod', label: 'sheet.field.provenanceMethod', value: 'method_for_provenance' },
+    { key: 'bibliography', label: 'sheet.field.bibliography', value: 'bibliography', render: 'block' },
+    { key: 'copyright', label: 'sheet.field.copyrightInformation', value: 'copyright' },
+  ]
+
+  const itemSheet = {
+    entity: 'items',
+    translations: ['glossary', 'dynasties', 'partners'],
+    // Attribution names are language-independent, but the importer files
+    // `author` / `copy_editor` for EPM records on the Arabic row only (a
+    // known gap, recorded in the exporter's README). Legacy printed them on
+    // every sheet, so the platform reads them off another row when the
+    // active one has neither — the one place a page reads across
+    // languages, and only for proper names.
+    attribution: ['author', 'copy_editor'],
+    fields,
+    layout: 'list',
+    shortDescription: 'short_description',
+    shortDescriptionAfter: 'description',
+    media: (record, { language }) =>
+      [...(record.images ?? [])]
+        .sort((a, b) => (a.display_order ?? 0) - (b.display_order ?? 0))
+        .map((p) => ({
+          url: p.url,
+          alt: labelOf('items', record.id),
+          caption: p.captions?.[language] ?? p.captions?.[defaultLang] ?? '',
+          photographer: p.photographer ?? '',
+          copyright: p.copyright ?? '',
+        })),
+    citation: { permalink: false, heading: 'record.citation.ofThisPage' },
+    related: {
+      variant: 'grid',
+      heading: 'record.related.items',
+      actionLabel: 'gallery.action.seeDatabaseEntry',
+      record: ({ record: other, justification }) => ({
+        id: other.id,
+        image: other.images?.[0]?.url ?? '',
+        imageAlt: labelOf('items', other.id),
+        name: mdInline(tr('items', other.id, defaultLang).name ?? other.internal_name ?? ''),
+        meta: [labelOf('countries', other.country_id), justification ? mdStrip(justification) : ''].filter(Boolean),
+        to: itemRoute(other),
+      }),
+    },
+    route: 'item',
+  }
+
+  return { itemSheet }
+}

package/src/dxa/gallery/useGalleryTimeline.js

@@ -0,0 +1,226 @@
+import { computed } from 'vue'
+import { dateRange, eraLabel, roundOutward, yearBucketsFromRange } from '../../catalogue/dates.js'
+import { useTimelineEvents } from '../../catalogue/timeline.js'
+import { PAGE_SIZE } from '../shared.js'
+
+export { eraLabel, roundOutward }
+
+/**
+ * The gallery's timeline spec, over its data layer's `data` and the
+ * `PAGE_SIZE`/`tile` its {@link import('./useGalleryCollection.js').useGalleryCollection}
+ * already declared.
+ *
+ * Reads `data.timelines`, `data.countries`, `data.countryById`,
+ * `data.labelOf`, `data.items`, `data.tr`, `data.loadTranslations`,
+ * `data.defaultLang`. `config` carries nothing today.
+ */
+export function useGalleryTimeline(data, collection, config = {}) {
+  void config
+  const { timelines, countries, countryById, labelOf, items, tr, loadTranslations, defaultLang } = data
+  const { tile } = collection
+
+  // `TimelineResultsView` takes `tr` as a plain callback rather than an
+  // entity name, unlike `CatalogueResultsView`/`RecordView`, which load
+  // their own entity's English translations when they mount. Nothing does
+  // that for this one, so it is done here, once, the moment this composable
+  // is created.
+  loadTranslations('timeline_events', defaultLang)
+
+  // The merge itself — the worldwide country chronology, `mwnf3.hcr`
+  // combined with Sharing History's exhibition-2 rows the way legacy's
+  // `/v2/events` served it — is viewer-core's `useTimelineEvents`. What
+  // stays here is what is genuinely a gallery's own: the DXA legacy
+  // 2-letter country code (a gallery's Timeline URLs are keyed on it, not
+  // on the inventory id) and the two specs the composed views render from.
+  //
+  // Names and legacy codes both come from countries.json. The exporter
+  // scopes that file to "member item countries ∪ their holders' countries ∪
+  // the global timeline's countries", so it covers every timeline country —
+  // the `Intl.DisplayNames` fallback below is therefore dead code for them,
+  // and is kept only so a regressed package degrades to a rendered ISO code
+  // rather than a raw id. The `code` countries.json ships is the country's
+  // `backward_compatibility`, which is exactly the code legacy's own
+  // timeline URLs used, including the ones that are not ISO 3166-1
+  // alpha-2 (`uk`, `pa`, `qt`, `rm`, `sb`, `ua`, …). Those are the reason
+  // the fallback must stay unreachable rather than merely rare: read as
+  // ISO, `ua` is Ukraine and `sb` is the Solomon Islands, where legacy
+  // means the UAE and Serbia. Only countries.json can name them correctly.
+  const regionNames = (() => {
+    try {
+      return new Intl.DisplayNames(['en'], { type: 'region' })
+    } catch {
+      return null
+    }
+  })()
+
+  // Two legacy codes are not ISO 3166-1 alpha-2.
+  const LEGACY_TO_ISO = { uk: 'GB', pa: 'PS' }
+
+  // `TimelineResultsView`'s own country control (`countries` from
+  // viewer-core) writes the inventory id, not the legacy code
+  // (`?country=dza`, not `?country=dz`); `countryIdForCode` used to answer
+  // nothing for one, silently matching every event. Built once, next to
+  // `LEGACY_TO_ISO`, rather than inside the function it is read from.
+  const countryIdSet = computed(() => new Set(countries.value.map((c) => c.id)))
+
+  // A lookup, not a parse. The fallback exists only for the
+  // regressed-package case described above, and it must agree with
+  // GLOBAL_TIMELINE_LIKE_PATTERNS in the exporter's timeline exporter: the
+  // country sits after the literal `country` segment in BOTH keyspaces
+  // (`mwnf3:hcr:country:<cc>` and
+  // `mwnf3_sharing_history:sh_hcr:country:<cc>:exhibition:2`), and it is
+  // the last segment in only the first — taking the last one yields `2` on
+  // the second.
+  function legacyCodeOf(timeline) {
+    const fromPackage = countryById.value.get(timeline.country_id)?.code
+    if (fromPackage) return fromPackage
+    const parts = (timeline.backward_compatibility ?? '').split(':')
+    const at = parts.indexOf('country')
+    return (at >= 0 ? parts[at + 1] : null) || timeline.country_id
+  }
+
+  function nameFor(timeline) {
+    const fromPackage = countries.value.some((c) => c.id === timeline.country_id)
+      ? labelOf('countries', timeline.country_id)
+      : null
+    if (fromPackage) return fromPackage
+    const legacy = legacyCodeOf(timeline)
+    const iso = LEGACY_TO_ISO[legacy] ?? String(legacy).toUpperCase()
+    try {
+      return regionNames?.of(iso) ?? iso
+    } catch {
+      return iso
+    }
+  }
+
+  /** Display name for a country the chronology carries, keyed by inventory id. */
+  function countryLabel(countryId) {
+    if (countries.value.some((c) => c.id === countryId)) return labelOf('countries', countryId)
+    const timeline = timelines.value.find((t) => t.country_id === countryId)
+    return timeline ? nameFor(timeline) : countryId
+  }
+
+  /**
+   * Legacy 2-letter code → the inventory country id the events are keyed
+   * by. A country served by both chronologies has two rows carrying the
+   * same code and the same `country_id`, so either row answers.
+   */
+  function countryIdForCode(code) {
+    if (!code || code === 'all') return null
+    // Already an id (the composed view's own control writes one): pass it
+    // through unchanged, before the legacy-code lookups below get a chance
+    // to find nothing and silently match every event.
+    if (countryIdSet.value.has(code)) return code
+    const timeline = timelines.value.find((t) => legacyCodeOf(t) === code)
+    if (timeline) return timeline.country_id
+    // Countries with no chronology still reach here from the collection
+    // page's "Timeline for this Search" link, which uses countries.json's
+    // own codes.
+    return countries.value.find((c) => c.code === code)?.id ?? null
+  }
+
+  /**
+   * The one merge engine every Timeline page on a gallery shares —
+   * worldwide, project-independent, which is why it works even though a
+   * gallery's own `has_country_timeline` flag is false, exactly as on the
+   * live site. `TimelineResultsView`'s two instances (entrance, results)
+   * each read the spec below and build their own; the item sheet's
+   * "Timeline for this item" widget is the one place that reads it
+   * directly, for a per-item country and range the composed view has no
+   * shape for.
+   */
+  const timelineEvents = useTimelineEvents({
+    scope: 'country',
+    countryLabel,
+    countryIdForCode,
+    tr: (id) => tr('timeline_events', id, defaultLang),
+  })
+
+  // ── The gallery join ──────────────────────────────────────────────────
+  //
+  // Legacy's timeline-gallery page joined events to member items by country
+  // and year range client-side; the package spec anticipated exactly this.
+  // Overlap, not containment: a period is a window on the chronology, and
+  // an object made across its edge belongs in it.
+
+  function inTimelineScope(item, countryCode) {
+    const countryId = countryIdForCode(countryCode)
+    return Number.isFinite(item.start_date) && (!countryId || item.country_id === countryId)
+  }
+
+  /** The member items in `filters.country`'s period — the "See gallery" count. */
+  function timelineGalleryItems({ country, begin, end } = {}) {
+    const list = (items.value ?? []).filter((i) => inTimelineScope(i, country))
+    return dateRange(list, { begin, end, mode: 'overlap' })
+  }
+
+  // ── The entrance and results page, as one spec ─────────────────────────
+  //
+  // What viewer-layout's `TimelineResultsView` renders on `/timeline`
+  // (entrance: true) and `/timeline-results` (entrance: false): the
+  // country and period controls, the events list, and the "See gallery"
+  // cross-link — shown whenever the chosen country and period actually
+  // contain member items, for every country including "all".
+
+  const timelineResults = {
+    scope: 'country',
+    countryLabel,
+    countryIdForCode,
+    tr: (id) => tr('timeline_events', id, defaultLang),
+    route: 'timeline-results',
+    controls: [
+      { key: 'country' },
+      { key: 'begin', options: (ctx) => yearBucketsFromRange(ctx.years.min, ctx.years.max, ctx.t) },
+      { key: 'end', options: (ctx) => yearBucketsFromRange(ctx.years.min, ctx.years.max, ctx.t) },
+    ],
+    gallery: {
+      route: 'timeline-gallery',
+      items: (ctx) => timelineGalleryItems(ctx.filters),
+    },
+  }
+
+  // ── The gallery page, as a spec ─────────────────────────────────────────
+  //
+  // What viewer-layout's `CatalogueResultsView` renders on
+  // `/timeline/gallery`: the same country-and-period join as the cross-link
+  // above, over the member items, undated last, nine tiles a page. No
+  // facets or controls: the country and period travel from the timeline
+  // results page, not from this page's own form.
+
+  const timelineGallery = {
+    entity: 'items',
+    // Named explicitly: there are no facets here for the default key list
+    // to infer 'country' from, only the join's own scope function.
+    keys: ['country', 'begin', 'end'],
+    scope: (item, filters) => inTimelineScope(item, filters.country),
+    dates: { mode: 'overlap' },
+    sort: { undated: 'first' },
+    pageSize: PAGE_SIZE,
+    variant: 'grid',
+    recordRoute: 'item',
+    actionLabel: 'gallery.action.seeDatabaseEntry',
+    empty: 'gallery.results.noObjectsInPeriod',
+    pagination: { jump: true },
+
+    record: (item, { t }) => tile(item, t),
+
+    summary: ({ filters, pageInfo, t }) => {
+      const countryId = countryIdForCode(filters.country)
+      const begin = filters.begin ? Number(filters.begin) : null
+      const end = filters.end ? Number(filters.end) : null
+      const parts = [{
+        label: t('timeline.results.galleryHeading'),
+        value: countryId ? labelOf('countries', countryId) : t('timeline.form.allCountries'),
+      }]
+      if (begin != null || end != null) {
+        const from = begin != null ? eraLabel(begin, t) : t('timeline.form.earliest')
+        const to = end != null ? eraLabel(end, t) : t('timeline.form.latest')
+        parts.push({ value: `${from} ${t('timeline.form.to')} ${to}` })
+      }
+      parts.push({ count: pageInfo.total, value: t('catalogue.results.objects') })
+      return parts
+    },
+  }
+
+  return { countryLabel, countryIdForCode, timelineEvents, timelineGalleryItems, timelineResults, timelineGallery }
+}

package/src/dxa/index.js

@@ -0,0 +1,34 @@
+// The DXA gallery/exhibition composables (epic #1730): the data layer,
+// catalogue spec, timeline spec, partner specs and item-sheet spec each of
+// the two live DXA site pairs (carpets/amulets — a gallery; the-use-of-
+// colours-in-art/water-in-islam — an exhibition) wrote for itself,
+// byte-identical within each pair. Promoted here per family, never as one
+// composable that papers over the two — the cross-family diff is real
+// behaviour (see each file's own header), not just naming.
+//
+// A site composes its own module from these, passing the `data` object one
+// family's `useGalleryData()`/`useExhibitionData()` call returns into the
+// rest:
+//
+//   import { useGalleryData, useGalleryCollection, useGalleryTimeline, useGalleryPartner, useGallerySheet } from '@museumwnf/viewer-core/dxa'
+//
+//   const data = useGalleryData()
+//   const collection = useGalleryCollection(data)
+//   const timeline = useGalleryTimeline(data, collection)
+//   const partner = useGalleryPartner(data, collection)
+//   const sheet = useGallerySheet(data)
+
+// Shared verbatim by both families — see shared.js.
+export { DATE_MODE, FACET_CATEGORIES, FACET_LABEL_KEYS, PAGE_SIZE, useFacetLabels } from './shared.js'
+
+export { useGalleryData } from './gallery/useGalleryData.js'
+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 { 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'

package/src/dxa/shared.js

@@ -0,0 +1,53 @@
+import { useI18n } from '../i18n/index.js'
+
+// The five THG catalogue facets, shared verbatim by both DXA families (a
+// gallery's and an exhibition's `useCollection.js` declared the exact same
+// four constants and helper) — everything else about a family's catalogue
+// spec (the facet *predicates*, the tile, the results spec) reads real
+// per-family data and stays in `gallery/useGalleryCollection.js` /
+// `exhibition/useExhibitionCollection.js`.
+
+/** Nine tiles a page, as legacy's grids showed. */
+export const PAGE_SIZE = 9
+
+/**
+ * Decision D5: the DXA sites test containment — `na <= start_date` and
+ * `nz >= coalesce(end_date, start_date)` in `Objects.blade.php` — so an
+ * undated record is out the moment a bound is set.
+ */
+export const DATE_MODE = 'contain'
+
+// The five THG facet categories, in the order the legacy form shows them.
+// `artist` has no dropdown in dxa-client, but the category exists in the
+// data and the exporter ships it, so it renders whenever it has a value — a
+// superset of legacy, never a different answer.
+export const FACET_CATEGORIES = ['type', 'dynasty', 'subject', 'material', 'artist']
+
+/**
+ * The heading each facet dropdown carries, as entry names. Written out once
+ * here so both the entrance's `SearchFormView` spec (which translates a
+ * facet's `label` itself) and the results page's own aside panel (which
+ * wants the translated string) read the same five names, and so
+ * `viewer-i18n-check` can see them.
+ */
+export const FACET_LABEL_KEYS = {
+  type: 'catalogue.facet.type',
+  dynasty: 'catalogue.facet.periodDynasty',
+  subject: 'catalogue.facet.subject',
+  material: 'catalogue.facet.material',
+  artist: 'catalogue.facet.artist',
+}
+
+// Every name written out, not read off `FACET_LABEL_KEYS` through a
+// variable: `viewer-i18n-check` only sees a name spelled out at the call
+// site, so a loop over the map above would be invisible to it.
+export function useFacetLabels() {
+  const { t } = useI18n()
+  return {
+    type: t('catalogue.facet.type'),
+    dynasty: t('catalogue.facet.periodDynasty'),
+    subject: t('catalogue.facet.subject'),
+    material: t('catalogue.facet.material'),
+    artist: t('catalogue.facet.artist'),
+  }
+}

package/src/index.js

@@ -1,4 +1,5 @@
 export { createViewer } from './createViewer.js'
+export { createStandardViewer } from './createStandardViewer.js'
 export { useCatalogueData } from './composables/useCatalogueData.js'
 export { useDataPackage } from './composables/useDataPackage.js'
 export { byId, entityRef, loadEntities, useEntities } from './composables/useEntities.js'