@museumwnf/viewer-core 1.14.0 → 1.15.1

package/package.json

@@ -1,50 +1,50 @@
-{
-  "name": "@museumwnf/viewer-core",
-  "version": "1.14.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",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/metanull/viewer-core.git"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "src"
-  ],
-  "main": "./src/index.js",
-  "module": "./src/index.js",
-  "exports": {
-    ".": "./src/index.js",
-    "./i18n": "./src/i18n/index.js",
-    "./legacy": "./src/legacy/index.js",
-    "./testing": "./src/testing/index.js",
-    "./vite": "./src/vite.js",
-    "./styles/base.css": "./src/styles/base.css"
-  },
-  "sideEffects": [
-    "**/*.css"
-  ],
-  "scripts": {
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "marked": "^18.0.11"
-  },
-  "peerDependencies": {
-    "vue": "^3.5.0",
-    "vue-router": "^4.5.0 || ^5.0.0"
-  },
-  "devDependencies": {
-    "@vitejs/plugin-vue": "^6.0.8",
-    "@vue/test-utils": "^2.4.11",
-    "jsdom": "^30.0.1",
-    "vite": "^8.2.2",
-    "vitest": "^4.1.11",
-    "vue": "^3.5.0",
-    "vue-router": "^5.0.0"
-  }
-}
+{
+  "name": "@museumwnf/viewer-core",
+  "version": "1.15.1",
+  "description": "Application engine for MWNF websites: turns a dataset.config.js into a mounted Vue application.",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/metanull/viewer-core.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src"
+  ],
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./i18n": "./src/i18n/index.js",
+    "./legacy": "./src/legacy/index.js",
+    "./testing": "./src/testing/index.js",
+    "./vite": "./src/vite.js",
+    "./styles/base.css": "./src/styles/base.css"
+  },
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "scripts": {
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "marked": "^18.0.11"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0",
+    "vue-router": "^4.5.0 || ^5.0.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^6.0.8",
+    "@vue/test-utils": "^2.4.11",
+    "jsdom": "^30.0.1",
+    "vite": "^8.2.2",
+    "vitest": "^4.1.11",
+    "vue": "^3.5.0",
+    "vue-router": "^5.0.0"
+  }
+}

package/src/AppRoot.vue

@@ -1,58 +1,58 @@
-<script setup>
-import { computed, inject, ref } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from './i18n/index.js'
-import { negotiateLanguage } from './i18n/language.js'
-import { VIEWER_CONFIG } from './injectionKeys.js'
-
-const config = inject(VIEWER_CONFIG, {})
-const { locale } = useI18n()
-const route = useRoute()
-const router = useRouter()
-
-// The shell receives the resolved language list, everything the website put in
-// config.navigation, and the current locale — in that order, so `language`
-// always reflects the live locale.
-const shellProps = computed(() => ({
-  languages: config.languages,
-  ...(config.navigation ?? {}),
-  language: locale.value,
-}))
-
-// The shell is the website's own component, so what it emits is checked here
-// rather than trusted: the active language is always one the website offers.
-function setLanguage(language) {
-  locale.value = negotiateLanguage(config.languages, { requested: language })
-}
-
-// Until the first navigation has resolved — which includes loading the
-// entities the route declares — there is no view to show, and the page says
-// so rather than staying blank.
-const navigating = ref(true)
-router.beforeEach(() => {
-  navigating.value = true
-})
-router.afterEach(() => {
-  navigating.value = false
-})
-router.onError(() => {
-  navigating.value = false
-})
-const loading = computed(() => navigating.value && route.matched.length === 0)
-</script>
-
-<template>
-  <component
-    :is="config.shell"
-    v-if="config.shell"
-    v-bind="shellProps"
-    @update:language="setLanguage"
-  >
-    <p v-if="loading" class="vc-loading">{{ $t('core.status.loading') }}</p>
-    <router-view v-else />
-  </component>
-  <template v-else>
-    <p v-if="loading" class="vc-loading">{{ $t('core.status.loading') }}</p>
-    <router-view v-else />
-  </template>
-</template>
+<script setup>
+import { computed, inject, ref } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import { useI18n } from './i18n/index.js'
+import { negotiateLanguage } from './i18n/language.js'
+import { VIEWER_CONFIG } from './injectionKeys.js'
+
+const config = inject(VIEWER_CONFIG, {})
+const { locale } = useI18n()
+const route = useRoute()
+const router = useRouter()
+
+// The shell receives the resolved language list, everything the website put in
+// config.navigation, and the current locale — in that order, so `language`
+// always reflects the live locale.
+const shellProps = computed(() => ({
+  languages: config.languages,
+  ...(config.navigation ?? {}),
+  language: locale.value,
+}))
+
+// The shell is the website's own component, so what it emits is checked here
+// rather than trusted: the active language is always one the website offers.
+function setLanguage(language) {
+  locale.value = negotiateLanguage(config.languages, { requested: language })
+}
+
+// Until the first navigation has resolved — which includes loading the
+// entities the route declares — there is no view to show, and the page says
+// so rather than staying blank.
+const navigating = ref(true)
+router.beforeEach(() => {
+  navigating.value = true
+})
+router.afterEach(() => {
+  navigating.value = false
+})
+router.onError(() => {
+  navigating.value = false
+})
+const loading = computed(() => navigating.value && route.matched.length === 0)
+</script>
+
+<template>
+  <component
+    :is="config.shell"
+    v-if="config.shell"
+    v-bind="shellProps"
+    @update:language="setLanguage"
+  >
+    <p v-if="loading" class="vc-loading">{{ $t('core.status.loading') }}</p>
+    <router-view v-else />
+  </component>
+  <template v-else>
+    <p v-if="loading" class="vc-loading">{{ $t('core.status.loading') }}</p>
+    <router-view v-else />
+  </template>
+</template>

package/src/catalogue/dates.js

@@ -1,209 +1,209 @@
-// Two date rules, both legacy, never merged.
-//
-// The standalone sites (Islamic Art, Baroque Art, Sharing History) test
-// overlap, tolerating a record that carries one date only: "from 800" keeps
-// a record whose end is at or after 800, or — with no end — whose start is.
-// The DXA sites (the galleries and exhibitions) test containment, the
-// predicate of legacy's `Objects.blade.php`: `na <= start_date` and
-// `nz >= coalesce(end_date, start_date)`, so an undated record is out the
-// moment a bound is set. They give different answers on the same data, and
-// each website has published its answer for years. A site names its rule
-// once, in its catalogue spec; this file only makes sure the two cannot be
-// confused for one.
-
-const number = (value) => {
-  if (value === '' || value == null) return null
-  const n = Number(value)
-  return Number.isFinite(n) ? n : null
-}
-
-const year = (record, field) => {
-  const value = record?.[field]
-  return typeof value === 'number' && Number.isFinite(value) ? value : null
-}
-
-/**
- * Whether `record` falls in `[begin, end]` under `mode`: `'overlap'` (the
- * standalone rule) or `'contain'` (the DXA rule). A bound that is empty or
- * absent is not applied. `fields` names the record's start and end properties.
- */
-export function inDateRange(record, { begin, end, mode = 'overlap', fields = {} } = {}) {
-  const from = number(begin)
-  const to = number(end)
-  const start = year(record, fields.start ?? 'start_date')
-  const last = year(record, fields.end ?? 'end_date')
-
-  if (mode === 'contain') {
-    if (from != null && (start == null || from > start)) return false
-    if (to != null) {
-      const final = last ?? start
-      if (final == null || to < final) return false
-    }
-    return true
-  }
-  if (mode !== 'overlap') throw new Error(`Unknown date mode "${mode}": use "overlap" or "contain"`)
-
-  if (from != null) {
-    if (last != null) {
-      if (last < from) return false
-    } else if (start != null && start < from) return false
-  }
-  if (to != null) {
-    if (start != null) {
-      if (start > to) return false
-    } else if (last != null && last > to) return false
-  }
-  return true
-}
-
-/** The records of `list` that `inDateRange` keeps. */
-export function dateRange(list, options = {}) {
-  return (list ?? []).filter((record) => inDateRange(record, options))
-}
-
-// ── Year buckets ───────────────────────────────────────────────────────────
-//
-// A verbatim port of `loadYears` in the legacy DXA client's collection.js
-// mixin, carried here from four identical copies. The API returned only a
-// min and a max; the client built the era buckets itself, with coarser steps
-// the further back you go (500 → 250 → 100 → 50), an explicit "Before 1000
-// BC" bucket, and an "After …" label when the final step is short. The
-// algorithm is reproduced rather than improved because its values end up in
-// shareable URLs, and a nicer bucket is a broken link.
-
-const nextMultiple = (n, m) => Math.ceil(n / m) * m
-const previousMultiple = (n, m) => Math.floor(n / m) * m
-
-function pushIncrements(from, maxRounded, incrementMax, increment, array) {
-  for (let i = from; i <= incrementMax; i += increment) {
-    if (i > maxRounded) return
-    array.push(i)
-  }
-}
-
-/**
- * The era buckets between `min` and `max`, as `[{ value, label }]`. The era
- * words on the labels are texts (`catalogue.era.bc`, `.ad`, `.before`,
- * `.after`) and the years are not, which is why `t` comes in from the caller
- * and the two are joined here rather than written into an entry with a hole
- * in it.
- */
-export function yearBucketsFromRange(min, max, t) {
-  if (!Number.isFinite(min) || !Number.isFinite(max)) return []
-
-  const increments = [500, 250, 100, 50]
-  let smallestIncrement
-  const array = [min]
-  let minRounded, maxRounded
-
-  if (max >= 1800) maxRounded = previousMultiple(max, increments[3])
-  else if (max >= 1000) maxRounded = previousMultiple(max, increments[2])
-  else if (max >= 0) maxRounded = previousMultiple(max, increments[1])
-  else maxRounded = previousMultiple(max, increments[0])
-
-  if (min <= 0) minRounded = nextMultiple(min, increments[0])
-  else if (min <= 1000) minRounded = nextMultiple(min, increments[1])
-  else if (min <= 1800) minRounded = nextMultiple(min, increments[2])
-  else minRounded = nextMultiple(min, increments[3])
-
-  let guard = 0
-  do {
-    if (minRounded < 0) {
-      pushIncrements(minRounded, maxRounded, 0, increments[0], array)
-      smallestIncrement = increments[0]
-    } else if (minRounded < 1000) {
-      pushIncrements(minRounded, maxRounded, 1000, increments[1], array)
-      smallestIncrement = increments[1]
-    } else if (minRounded < 1800) {
-      pushIncrements(minRounded, maxRounded, 1800, increments[2], array)
-      smallestIncrement = increments[2]
-    } else {
-      pushIncrements(minRounded, maxRounded, maxRounded, increments[3], array)
-      smallestIncrement = increments[3]
-    }
-    const last = array[array.length - 1]
-    // The legacy loop relies on the array growing; if a step adds nothing it
-    // would spin forever. Legacy never hit that because its data always did.
-    if (last === minRounded && guard++ > 0) break
-    minRounded = last
-  } while (array[array.length - 1] < maxRounded && guard++ < 64)
-
-  array.push(max)
-  const unique = [...new Set(array)]
-
-  const labelled = []
-  for (const value of unique) {
-    if (value < 0) labelled.push({ value, label: `${Math.abs(value)} ${t('catalogue.era.bc')}` })
-    else if (value > 0) labelled.push({ value, label: `${value} ${t('catalogue.era.ad')}` })
-  }
-  if (!labelled.length) return []
-
-  let display = labelled
-  if (labelled[0].value < -1000) {
-    display = labelled.filter(({ value }) => value >= -1000)
-    display.unshift({ value: min, label: `${t('catalogue.era.before')} 1000 ${t('catalogue.era.bc')}` })
-  }
-
-  if (display.length > 1) {
-    const lastGap = display[display.length - 1].value - display[display.length - 2].value
-    if (lastGap < smallestIncrement) {
-      const previous = display[display.length - 2]
-      display[display.length - 1] = {
-        value: display[display.length - 1].value,
-        label: `${t('catalogue.era.after')} ${previous.label}`,
-      }
-    }
-  }
-  return display
-}
-
-/** The buckets spanning the dates of `records` (`start_date` to `end_date ?? start_date`). */
-export function yearBuckets(records, t, { fields = {} } = {}) {
-  const startField = fields.start ?? 'start_date'
-  const endField = fields.end ?? 'end_date'
-  const starts = []
-  const ends = []
-  for (const record of records ?? []) {
-    const start = year(record, startField)
-    const end = year(record, endField) ?? start
-    if (start != null) starts.push(start)
-    if (end != null) ends.push(end)
-  }
-  if (!starts.length || !ends.length) return []
-  return yearBucketsFromRange(Math.min(...starts), Math.max(...ends), t)
-}
-
-/**
- * "1193 AD" / "502 BC" — legacy's era suffix rule, for a year on its own.
- * Nothing for a year that is missing or zero.
- */
-export function eraLabel(year, t) {
-  if (!Number.isFinite(year) || year === 0) return ''
-  return year < 0 ? `${Math.abs(year)} ${t('catalogue.era.bc')}` : `${year} ${t('catalogue.era.ad')}`
-}
-
-/**
- * A record's dates rounded outward to the century, the window legacy's
- * "Timeline for this item" opens, so a single-year object still lands on a
- * readable stretch of chronology. `[from, to]`, either null when unknown.
- */
-export function roundOutward(start, end) {
-  const from = Number.isFinite(start) ? Math.floor(start / 100) * 100 : null
-  const last = Number.isFinite(end) ? end : start
-  const to = Number.isFinite(last) ? Math.ceil(last / 100) * 100 : null
-  return [from, to]
-}
-
-/**
- * The century boundaries that three Database forms build locally, reproducing
- * legacy `database.php:88–124`. The asymmetry between the two lists is preserved.
- * The default range (501–2000) is the same as the legacy form's initial state.
- */
-export function centuryPresets({ from = 501, to = 2000 } = {}) {
-  const fromOptions = Array.from({ length: 16 }, (_, i) => 501 + i * 100)
-  const toOptions = Array.from({ length: 15 }, (_, i) => 600 + i * 100)
-  return {
-    from: fromOptions,
-    to: toOptions,
-  }
-}
+// Two date rules, both legacy, never merged.
+//
+// The standalone sites (Islamic Art, Baroque Art, Sharing History) test
+// overlap, tolerating a record that carries one date only: "from 800" keeps
+// a record whose end is at or after 800, or — with no end — whose start is.
+// The DXA sites (the galleries and exhibitions) test containment, the
+// predicate of legacy's `Objects.blade.php`: `na <= start_date` and
+// `nz >= coalesce(end_date, start_date)`, so an undated record is out the
+// moment a bound is set. They give different answers on the same data, and
+// each website has published its answer for years. A site names its rule
+// once, in its catalogue spec; this file only makes sure the two cannot be
+// confused for one.
+
+const number = (value) => {
+  if (value === '' || value == null) return null
+  const n = Number(value)
+  return Number.isFinite(n) ? n : null
+}
+
+const year = (record, field) => {
+  const value = record?.[field]
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+/**
+ * Whether `record` falls in `[begin, end]` under `mode`: `'overlap'` (the
+ * standalone rule) or `'contain'` (the DXA rule). A bound that is empty or
+ * absent is not applied. `fields` names the record's start and end properties.
+ */
+export function inDateRange(record, { begin, end, mode = 'overlap', fields = {} } = {}) {
+  const from = number(begin)
+  const to = number(end)
+  const start = year(record, fields.start ?? 'start_date')
+  const last = year(record, fields.end ?? 'end_date')
+
+  if (mode === 'contain') {
+    if (from != null && (start == null || from > start)) return false
+    if (to != null) {
+      const final = last ?? start
+      if (final == null || to < final) return false
+    }
+    return true
+  }
+  if (mode !== 'overlap') throw new Error(`Unknown date mode "${mode}": use "overlap" or "contain"`)
+
+  if (from != null) {
+    if (last != null) {
+      if (last < from) return false
+    } else if (start != null && start < from) return false
+  }
+  if (to != null) {
+    if (start != null) {
+      if (start > to) return false
+    } else if (last != null && last > to) return false
+  }
+  return true
+}
+
+/** The records of `list` that `inDateRange` keeps. */
+export function dateRange(list, options = {}) {
+  return (list ?? []).filter((record) => inDateRange(record, options))
+}
+
+// ── Year buckets ───────────────────────────────────────────────────────────
+//
+// A verbatim port of `loadYears` in the legacy DXA client's collection.js
+// mixin, carried here from four identical copies. The API returned only a
+// min and a max; the client built the era buckets itself, with coarser steps
+// the further back you go (500 → 250 → 100 → 50), an explicit "Before 1000
+// BC" bucket, and an "After …" label when the final step is short. The
+// algorithm is reproduced rather than improved because its values end up in
+// shareable URLs, and a nicer bucket is a broken link.
+
+const nextMultiple = (n, m) => Math.ceil(n / m) * m
+const previousMultiple = (n, m) => Math.floor(n / m) * m
+
+function pushIncrements(from, maxRounded, incrementMax, increment, array) {
+  for (let i = from; i <= incrementMax; i += increment) {
+    if (i > maxRounded) return
+    array.push(i)
+  }
+}
+
+/**
+ * The era buckets between `min` and `max`, as `[{ value, label }]`. The era
+ * words on the labels are texts (`catalogue.era.bc`, `.ad`, `.before`,
+ * `.after`) and the years are not, which is why `t` comes in from the caller
+ * and the two are joined here rather than written into an entry with a hole
+ * in it.
+ */
+export function yearBucketsFromRange(min, max, t) {
+  if (!Number.isFinite(min) || !Number.isFinite(max)) return []
+
+  const increments = [500, 250, 100, 50]
+  let smallestIncrement
+  const array = [min]
+  let minRounded, maxRounded
+
+  if (max >= 1800) maxRounded = previousMultiple(max, increments[3])
+  else if (max >= 1000) maxRounded = previousMultiple(max, increments[2])
+  else if (max >= 0) maxRounded = previousMultiple(max, increments[1])
+  else maxRounded = previousMultiple(max, increments[0])
+
+  if (min <= 0) minRounded = nextMultiple(min, increments[0])
+  else if (min <= 1000) minRounded = nextMultiple(min, increments[1])
+  else if (min <= 1800) minRounded = nextMultiple(min, increments[2])
+  else minRounded = nextMultiple(min, increments[3])
+
+  let guard = 0
+  do {
+    if (minRounded < 0) {
+      pushIncrements(minRounded, maxRounded, 0, increments[0], array)
+      smallestIncrement = increments[0]
+    } else if (minRounded < 1000) {
+      pushIncrements(minRounded, maxRounded, 1000, increments[1], array)
+      smallestIncrement = increments[1]
+    } else if (minRounded < 1800) {
+      pushIncrements(minRounded, maxRounded, 1800, increments[2], array)
+      smallestIncrement = increments[2]
+    } else {
+      pushIncrements(minRounded, maxRounded, maxRounded, increments[3], array)
+      smallestIncrement = increments[3]
+    }
+    const last = array[array.length - 1]
+    // The legacy loop relies on the array growing; if a step adds nothing it
+    // would spin forever. Legacy never hit that because its data always did.
+    if (last === minRounded && guard++ > 0) break
+    minRounded = last
+  } while (array[array.length - 1] < maxRounded && guard++ < 64)
+
+  array.push(max)
+  const unique = [...new Set(array)]
+
+  const labelled = []
+  for (const value of unique) {
+    if (value < 0) labelled.push({ value, label: `${Math.abs(value)} ${t('catalogue.era.bc')}` })
+    else if (value > 0) labelled.push({ value, label: `${value} ${t('catalogue.era.ad')}` })
+  }
+  if (!labelled.length) return []
+
+  let display = labelled
+  if (labelled[0].value < -1000) {
+    display = labelled.filter(({ value }) => value >= -1000)
+    display.unshift({ value: min, label: `${t('catalogue.era.before')} 1000 ${t('catalogue.era.bc')}` })
+  }
+
+  if (display.length > 1) {
+    const lastGap = display[display.length - 1].value - display[display.length - 2].value
+    if (lastGap < smallestIncrement) {
+      const previous = display[display.length - 2]
+      display[display.length - 1] = {
+        value: display[display.length - 1].value,
+        label: `${t('catalogue.era.after')} ${previous.label}`,
+      }
+    }
+  }
+  return display
+}
+
+/** The buckets spanning the dates of `records` (`start_date` to `end_date ?? start_date`). */
+export function yearBuckets(records, t, { fields = {} } = {}) {
+  const startField = fields.start ?? 'start_date'
+  const endField = fields.end ?? 'end_date'
+  const starts = []
+  const ends = []
+  for (const record of records ?? []) {
+    const start = year(record, startField)
+    const end = year(record, endField) ?? start
+    if (start != null) starts.push(start)
+    if (end != null) ends.push(end)
+  }
+  if (!starts.length || !ends.length) return []
+  return yearBucketsFromRange(Math.min(...starts), Math.max(...ends), t)
+}
+
+/**
+ * "1193 AD" / "502 BC" — legacy's era suffix rule, for a year on its own.
+ * Nothing for a year that is missing or zero.
+ */
+export function eraLabel(year, t) {
+  if (!Number.isFinite(year) || year === 0) return ''
+  return year < 0 ? `${Math.abs(year)} ${t('catalogue.era.bc')}` : `${year} ${t('catalogue.era.ad')}`
+}
+
+/**
+ * A record's dates rounded outward to the century, the window legacy's
+ * "Timeline for this item" opens, so a single-year object still lands on a
+ * readable stretch of chronology. `[from, to]`, either null when unknown.
+ */
+export function roundOutward(start, end) {
+  const from = Number.isFinite(start) ? Math.floor(start / 100) * 100 : null
+  const last = Number.isFinite(end) ? end : start
+  const to = Number.isFinite(last) ? Math.ceil(last / 100) * 100 : null
+  return [from, to]
+}
+
+/**
+ * The century boundaries that three Database forms build locally, reproducing
+ * legacy `database.php:88–124`. The asymmetry between the two lists is preserved.
+ * The default range (501–2000) is the same as the legacy form's initial state.
+ */
+export function centuryPresets({ from = 501, to = 2000 } = {}) {
+  const fromOptions = Array.from({ length: 16 }, (_, i) => 501 + i * 100)
+  const toOptions = Array.from({ length: 15 }, (_, i) => 600 + i * 100)
+  return {
+    from: fromOptions,
+    to: toOptions,
+  }
+}