@museumwnf/viewer-core 1.14.0 → 1.15.0

package/src/composables/useCatalogueData.js

@@ -1,141 +1,141 @@
-import { computed } from 'vue'
-import { useDataPackage } from './useDataPackage.js'
-import { byId as coreById, entityRef } from './useEntities.js'
-import { md as coreMd, mdInline as coreMdInline, mdStrip as coreMdStrip } from '../i18n/markdown.js'
-import { glossaryEntries } from '../record/recordSheet.js'
-
-// The wrapper half of seven sites' data composables (2,376 lines across
-// them), written once. Every one of them re-wrapped the same `tr`, the same
-// memoised `loadEnglish`, the same one-shape label helper
-// (`mdStrip(tr(entity, id).name ?? record.internal_name ?? id)`), and the
-// same `md`/`mdInline`/`mdStrip` re-export, around whichever entities and
-// visibility rules were its own — a per-build language filter, a hidden-
-// partner rule, `display_status` — coded rather than declared. This is that
-// wrapper. What survives in a site's own composable is what genuinely
-// differs: routes, legacy key mappings, chrome images, sibling lists.
-//
-// Called once, at the top of a site's data composable module, and its
-// return value re-exported from there — the way `entityRef`/`byId` are
-// already read at module scope, so importing the module loads nothing and a
-// page pays only for the entity it declares. `entity`/`index` read the same
-// shared `entityRef`/`byId` this file does, so a second call would only
-// duplicate the memoisation `loadEnglish` and the glossary binding carry —
-// one instance per site, not one per component.
-const BASE_LANGUAGE = 'en'
-
-// A term's spellings and definition in one language, falling back to
-// English, then to the term's own headword — the same row shape
-// `useRecordSheet`'s `termRow` builds, but for the whole glossary in
-// `defaultLanguage` rather than one record's `glossary_ids` in the record's
-// own language, which is why it is not reused: a catalogue list or a label
-// is always shown in `defaultLanguage`, a record sheet's text is not.
-function glossaryRows(language, translations) {
-  const rows = translations('glossary', language)
-  const fallback = translations('glossary', BASE_LANGUAGE)
-  const terms = []
-  for (const term of entityRef('glossary').value ?? []) {
-    const t = rows[term.id] ?? fallback[term.id] ?? {}
-    const spellings = (t.spellings ?? []).map((s) => String(s).trim()).filter(Boolean)
-    const word = term.word ?? spellings[0] ?? ''
-    if (!word && spellings.length === 0) continue
-    terms.push({ id: term.id, word, definition: t.definition ?? '', spellings: spellings.length ? spellings : [word] })
-  }
-  return terms
-}
-
-/**
- * The wrapper half of a website's data composable: `tr`, `md`/`mdInline`/
- * `mdStrip` bound to the site's glossary, `loadEnglish`, `labelOf`, the
- * visible form of an entity and its index, and the package re-exports.
- *
- * `eager` names the entities `loadEnglish` loads — every entity the package
- * carries by default. `defaultLanguage` is the language `tr`, the labels and
- * the glossary binding read (`'en'` for every site so far). `visible` names,
- * per entity, the predicate `entity()`/`index()` apply — a per-build
- * language filter, a hidden-partner rule, a display-status check are all
- * "which records this build shows", declared here once instead of coded
- * into every page that lists that entity. `glossary` turns off the default
- * binding on `md`/`mdInline` (a caller may still pass its own `glossary` to
- * either, on or off).
- */
-export function useCatalogueData({ eager, defaultLanguage = BASE_LANGUAGE, visible = {}, glossary = true } = {}) {
-  const pkg = useDataPackage()
-  const { availableLanguages, loadTranslations, translations } = pkg
-  const eagerEntities = eager ?? pkg.entityNames
-
-  /** One record's translated fields, falling back to `defaultLanguage` then `{}`. */
-  function tr(entity, id, lang = defaultLanguage) {
-    return pkg.tr(entity, id, lang, defaultLanguage)
-  }
-
-  const defaultGlossary = computed(() =>
-    glossary ? glossaryEntries(glossaryRows(defaultLanguage, translations)) : [],
-  )
-
-  // A caller's own `glossary` — a record's own terms, not every term in the
-  // package — always wins, whether the default binding is on or off; `md`
-  // and `mdInline` differ only in which core renderer they wrap, `mdStrip`
-  // has nothing to bind, since plain text carries no highlighting.
-  function bindGlossary(renderer) {
-    return (text, opts = {}) =>
-      renderer(text, { ...opts, glossary: 'glossary' in opts ? opts.glossary : defaultGlossary.value })
-  }
-  const md = bindGlossary(coreMd)
-  const mdInline = bindGlossary(coreMdInline)
-  const mdStrip = coreMdStrip
-
-  /** `mdStrip(tr(entity, id).name ?? record[fallback] ?? id)` — the one label shape every site wrote. */
-  function labelOf(entity, id, { fallback = 'internal_name' } = {}) {
-    if (!id) return ''
-    const name = tr(entity, id).name
-    if (name) return mdStrip(name)
-    const record = coreById(entity).value.get(id)
-    return mdStrip(record?.[fallback] ?? id)
-  }
-
-  let englishReady = null
-  /** Loads `defaultLanguage` for every entity in `eager`, once. */
-  function loadEnglish() {
-    if (!englishReady) {
-      englishReady = Promise.all(eagerEntities.map((name) => loadTranslations(name, defaultLanguage)))
-    }
-    return englishReady
-  }
-
-  // Cached the way `byId` is: a site reads `entity('items')`/`index('items')`
-  // from more than one place, and each should see the same ref rather than
-  // a fresh filter pass and a fresh Map per call.
-  const entityCache = new Map()
-  /** `entityRef(name)`'s records, narrowed by `visible[name]` when one is declared; `null` until loaded. */
-  function entity(name) {
-    let ref = entityCache.get(name)
-    if (!ref) {
-      const source = entityRef(name)
-      const predicate = visible[name]
-      ref = computed(() => {
-        if (source.value === null) return null
-        return predicate ? source.value.filter(predicate) : source.value
-      })
-      entityCache.set(name, ref)
-    }
-    return ref
-  }
-
-  const indexCache = new Map()
-  /** A `Map` of `entity(name)`'s records by `key` — the visible ones, unlike `byId`. */
-  function index(name, key = 'id') {
-    const cacheKey = `${name}.${key}`
-    let ref = indexCache.get(cacheKey)
-    if (!ref) {
-      const list = entity(name)
-      ref = computed(() => new Map((list.value ?? []).map((record) => [record[key], record])))
-      indexCache.set(cacheKey, ref)
-    }
-    return ref
-  }
-
-  return {
-    tr, md, mdInline, mdStrip, loadEnglish, labelOf, entity, index,
-    availableLanguages, loadTranslations, translations,
-  }
-}
+import { computed } from 'vue'
+import { useDataPackage } from './useDataPackage.js'
+import { byId as coreById, entityRef } from './useEntities.js'
+import { md as coreMd, mdInline as coreMdInline, mdStrip as coreMdStrip } from '../i18n/markdown.js'
+import { glossaryEntries } from '../record/recordSheet.js'
+
+// The wrapper half of seven sites' data composables (2,376 lines across
+// them), written once. Every one of them re-wrapped the same `tr`, the same
+// memoised `loadEnglish`, the same one-shape label helper
+// (`mdStrip(tr(entity, id).name ?? record.internal_name ?? id)`), and the
+// same `md`/`mdInline`/`mdStrip` re-export, around whichever entities and
+// visibility rules were its own — a per-build language filter, a hidden-
+// partner rule, `display_status` — coded rather than declared. This is that
+// wrapper. What survives in a site's own composable is what genuinely
+// differs: routes, legacy key mappings, chrome images, sibling lists.
+//
+// Called once, at the top of a site's data composable module, and its
+// return value re-exported from there — the way `entityRef`/`byId` are
+// already read at module scope, so importing the module loads nothing and a
+// page pays only for the entity it declares. `entity`/`index` read the same
+// shared `entityRef`/`byId` this file does, so a second call would only
+// duplicate the memoisation `loadEnglish` and the glossary binding carry —
+// one instance per site, not one per component.
+const BASE_LANGUAGE = 'en'
+
+// A term's spellings and definition in one language, falling back to
+// English, then to the term's own headword — the same row shape
+// `useRecordSheet`'s `termRow` builds, but for the whole glossary in
+// `defaultLanguage` rather than one record's `glossary_ids` in the record's
+// own language, which is why it is not reused: a catalogue list or a label
+// is always shown in `defaultLanguage`, a record sheet's text is not.
+function glossaryRows(language, translations) {
+  const rows = translations('glossary', language)
+  const fallback = translations('glossary', BASE_LANGUAGE)
+  const terms = []
+  for (const term of entityRef('glossary').value ?? []) {
+    const t = rows[term.id] ?? fallback[term.id] ?? {}
+    const spellings = (t.spellings ?? []).map((s) => String(s).trim()).filter(Boolean)
+    const word = term.word ?? spellings[0] ?? ''
+    if (!word && spellings.length === 0) continue
+    terms.push({ id: term.id, word, definition: t.definition ?? '', spellings: spellings.length ? spellings : [word] })
+  }
+  return terms
+}
+
+/**
+ * The wrapper half of a website's data composable: `tr`, `md`/`mdInline`/
+ * `mdStrip` bound to the site's glossary, `loadEnglish`, `labelOf`, the
+ * visible form of an entity and its index, and the package re-exports.
+ *
+ * `eager` names the entities `loadEnglish` loads — every entity the package
+ * carries by default. `defaultLanguage` is the language `tr`, the labels and
+ * the glossary binding read (`'en'` for every site so far). `visible` names,
+ * per entity, the predicate `entity()`/`index()` apply — a per-build
+ * language filter, a hidden-partner rule, a display-status check are all
+ * "which records this build shows", declared here once instead of coded
+ * into every page that lists that entity. `glossary` turns off the default
+ * binding on `md`/`mdInline` (a caller may still pass its own `glossary` to
+ * either, on or off).
+ */
+export function useCatalogueData({ eager, defaultLanguage = BASE_LANGUAGE, visible = {}, glossary = true } = {}) {
+  const pkg = useDataPackage()
+  const { availableLanguages, loadTranslations, translations } = pkg
+  const eagerEntities = eager ?? pkg.entityNames
+
+  /** One record's translated fields, falling back to `defaultLanguage` then `{}`. */
+  function tr(entity, id, lang = defaultLanguage) {
+    return pkg.tr(entity, id, lang, defaultLanguage)
+  }
+
+  const defaultGlossary = computed(() =>
+    glossary ? glossaryEntries(glossaryRows(defaultLanguage, translations)) : [],
+  )
+
+  // A caller's own `glossary` — a record's own terms, not every term in the
+  // package — always wins, whether the default binding is on or off; `md`
+  // and `mdInline` differ only in which core renderer they wrap, `mdStrip`
+  // has nothing to bind, since plain text carries no highlighting.
+  function bindGlossary(renderer) {
+    return (text, opts = {}) =>
+      renderer(text, { ...opts, glossary: 'glossary' in opts ? opts.glossary : defaultGlossary.value })
+  }
+  const md = bindGlossary(coreMd)
+  const mdInline = bindGlossary(coreMdInline)
+  const mdStrip = coreMdStrip
+
+  /** `mdStrip(tr(entity, id).name ?? record[fallback] ?? id)` — the one label shape every site wrote. */
+  function labelOf(entity, id, { fallback = 'internal_name' } = {}) {
+    if (!id) return ''
+    const name = tr(entity, id).name
+    if (name) return mdStrip(name)
+    const record = coreById(entity).value.get(id)
+    return mdStrip(record?.[fallback] ?? id)
+  }
+
+  let englishReady = null
+  /** Loads `defaultLanguage` for every entity in `eager`, once. */
+  function loadEnglish() {
+    if (!englishReady) {
+      englishReady = Promise.all(eagerEntities.map((name) => loadTranslations(name, defaultLanguage)))
+    }
+    return englishReady
+  }
+
+  // Cached the way `byId` is: a site reads `entity('items')`/`index('items')`
+  // from more than one place, and each should see the same ref rather than
+  // a fresh filter pass and a fresh Map per call.
+  const entityCache = new Map()
+  /** `entityRef(name)`'s records, narrowed by `visible[name]` when one is declared; `null` until loaded. */
+  function entity(name) {
+    let ref = entityCache.get(name)
+    if (!ref) {
+      const source = entityRef(name)
+      const predicate = visible[name]
+      ref = computed(() => {
+        if (source.value === null) return null
+        return predicate ? source.value.filter(predicate) : source.value
+      })
+      entityCache.set(name, ref)
+    }
+    return ref
+  }
+
+  const indexCache = new Map()
+  /** A `Map` of `entity(name)`'s records by `key` — the visible ones, unlike `byId`. */
+  function index(name, key = 'id') {
+    const cacheKey = `${name}.${key}`
+    let ref = indexCache.get(cacheKey)
+    if (!ref) {
+      const list = entity(name)
+      ref = computed(() => new Map((list.value ?? []).map((record) => [record[key], record])))
+      indexCache.set(cacheKey, ref)
+    }
+    return ref
+  }
+
+  return {
+    tr, md, mdInline, mdStrip, loadEnglish, labelOf, entity, index,
+    availableLanguages, loadTranslations, translations,
+  }
+}

package/src/composables/useDataPackage.js

@@ -1,98 +1,98 @@
-import { ref } from 'vue'
-
-// package.json is npm metadata, not an entity — exclude it from the glob.
-const entityModules = import.meta.glob(['@inventory-data/*.json', '!**/package.json'])
-const manifestModules = import.meta.glob('@inventory-data/manifest.json', { eager: true })
-
-// One file per entity per language; a file is simply absent when that entity
-// has no translation in that language. Left lazy (unlike entityModules'
-// eager-in-spirit-but-actually-per-call loaders, this one also needs a
-// reactive cache — see below) so a build only bundles what a page visit
-// actually requests, not every language of every entity.
-const translationModules = import.meta.glob('@inventory-data/translations/*.json')
-
-const manifest = Object.values(manifestModules)[0]?.default ?? {}
-
-const entityLoaders = {}
-for (const [path, load] of Object.entries(entityModules)) {
-  const name = path.split('/').pop().replace(/\.json$/, '')
-  if (name !== 'manifest') {
-    entityLoaders[name] = load
-  }
-}
-
-function translationLoader(entity, lang) {
-  const suffix = `/translations/${entity}.${lang}.json`
-  const path = Object.keys(translationModules).find((k) => k.endsWith(suffix))
-  return path ? translationModules[path] : null
-}
-
-// `${entity}.${lang}` → record map, or `{}` once a miss has been resolved.
-// A plain `await import()` would already be deduped by the module system;
-// this cache exists so a component reading through `translations`/`tr` -
-// synchronous, not awaited - re-renders once a lazy `loadTranslations` call
-// elsewhere resolves.
-const translationCache = ref({})
-
-export function useDataPackage() {
-  return {
-    manifest,
-    languages: manifest.languages ?? ['en'],
-    entityNames: Object.keys(entityLoaders).sort(),
-    async loadEntity(name) {
-      const load = entityLoaders[name]
-      if (!load) {
-        throw new Error(`Unknown entity "${name}" in the data package`)
-      }
-      const module = await load()
-      return module.default ?? module
-    },
-
-    /** Languages `translations/<entity>.<lang>.json` actually exists for. */
-    availableLanguages(entity) {
-      const prefix = `/translations/${entity}.`
-      return Object.keys(translationModules)
-        .filter((k) => k.includes(prefix))
-        .map((k) => k.slice(k.lastIndexOf(prefix) + prefix.length, -'.json'.length))
-    },
-
-    /**
-     * Lazy-loads `translations/<entity>.<lang>.json` (a map of record id to
-     * that record's translated fields); `{}` when the file does not exist.
-     * Cached, so calling it again for the same pair is free.
-     */
-    async loadTranslations(entity, lang) {
-      const key = `${entity}.${lang}`
-      if (translationCache.value[key]) return translationCache.value[key]
-      const load = translationLoader(entity, lang)
-      let data = {}
-      if (load) {
-        try {
-          data = (await load()).default ?? {}
-        } catch {
-          data = {}
-        }
-      }
-      translationCache.value = { ...translationCache.value, [key]: data }
-      return data
-    },
-
-    /** Already-loaded translations for one entity/lang; `{}` if not loaded yet (or absent). */
-    translations(entity, lang) {
-      return translationCache.value[`${entity}.${lang}`] ?? {}
-    },
-
-    /**
-     * One record's translated fields, falling back to `fallbackLang` (default
-     * `'en'`) then to `{}`. Reads only what is already loaded — call
-     * `loadTranslations` first for each language a page may need.
-     */
-    tr(entity, id, lang, fallbackLang = 'en') {
-      return (
-        translationCache.value[`${entity}.${lang}`]?.[id] ??
-        translationCache.value[`${entity}.${fallbackLang}`]?.[id] ??
-        {}
-      )
-    },
-  }
-}
+import { ref } from 'vue'
+
+// package.json is npm metadata, not an entity — exclude it from the glob.
+const entityModules = import.meta.glob(['@inventory-data/*.json', '!**/package.json'])
+const manifestModules = import.meta.glob('@inventory-data/manifest.json', { eager: true })
+
+// One file per entity per language; a file is simply absent when that entity
+// has no translation in that language. Left lazy (unlike entityModules'
+// eager-in-spirit-but-actually-per-call loaders, this one also needs a
+// reactive cache — see below) so a build only bundles what a page visit
+// actually requests, not every language of every entity.
+const translationModules = import.meta.glob('@inventory-data/translations/*.json')
+
+const manifest = Object.values(manifestModules)[0]?.default ?? {}
+
+const entityLoaders = {}
+for (const [path, load] of Object.entries(entityModules)) {
+  const name = path.split('/').pop().replace(/\.json$/, '')
+  if (name !== 'manifest') {
+    entityLoaders[name] = load
+  }
+}
+
+function translationLoader(entity, lang) {
+  const suffix = `/translations/${entity}.${lang}.json`
+  const path = Object.keys(translationModules).find((k) => k.endsWith(suffix))
+  return path ? translationModules[path] : null
+}
+
+// `${entity}.${lang}` → record map, or `{}` once a miss has been resolved.
+// A plain `await import()` would already be deduped by the module system;
+// this cache exists so a component reading through `translations`/`tr` -
+// synchronous, not awaited - re-renders once a lazy `loadTranslations` call
+// elsewhere resolves.
+const translationCache = ref({})
+
+export function useDataPackage() {
+  return {
+    manifest,
+    languages: manifest.languages ?? ['en'],
+    entityNames: Object.keys(entityLoaders).sort(),
+    async loadEntity(name) {
+      const load = entityLoaders[name]
+      if (!load) {
+        throw new Error(`Unknown entity "${name}" in the data package`)
+      }
+      const module = await load()
+      return module.default ?? module
+    },
+
+    /** Languages `translations/<entity>.<lang>.json` actually exists for. */
+    availableLanguages(entity) {
+      const prefix = `/translations/${entity}.`
+      return Object.keys(translationModules)
+        .filter((k) => k.includes(prefix))
+        .map((k) => k.slice(k.lastIndexOf(prefix) + prefix.length, -'.json'.length))
+    },
+
+    /**
+     * Lazy-loads `translations/<entity>.<lang>.json` (a map of record id to
+     * that record's translated fields); `{}` when the file does not exist.
+     * Cached, so calling it again for the same pair is free.
+     */
+    async loadTranslations(entity, lang) {
+      const key = `${entity}.${lang}`
+      if (translationCache.value[key]) return translationCache.value[key]
+      const load = translationLoader(entity, lang)
+      let data = {}
+      if (load) {
+        try {
+          data = (await load()).default ?? {}
+        } catch {
+          data = {}
+        }
+      }
+      translationCache.value = { ...translationCache.value, [key]: data }
+      return data
+    },
+
+    /** Already-loaded translations for one entity/lang; `{}` if not loaded yet (or absent). */
+    translations(entity, lang) {
+      return translationCache.value[`${entity}.${lang}`] ?? {}
+    },
+
+    /**
+     * One record's translated fields, falling back to `fallbackLang` (default
+     * `'en'`) then to `{}`. Reads only what is already loaded — call
+     * `loadTranslations` first for each language a page may need.
+     */
+    tr(entity, id, lang, fallbackLang = 'en') {
+      return (
+        translationCache.value[`${entity}.${lang}`]?.[id] ??
+        translationCache.value[`${entity}.${fallbackLang}`]?.[id] ??
+        {}
+      )
+    },
+  }
+}