@glossarist/concept-browser 0.7.34 → 0.7.37

package/src/adapters/model-bridge.ts

@@ -73,18 +73,18 @@ interface JsonLdRef {
   'gl:id'?: string;
   'gl:version'?: string;
   'gl:text'?: string;
-  'source'?: string;
-  'id'?: string;
-  'version'?: string;
+  source?: string;
+  id?: string;
+  version?: string;
 }
 
 interface JsonLdLocality {
   'gl:localityType'?: string;
   'gl:referenceFrom'?: string;
   'gl:referenceTo'?: string;
-  'type'?: string;
-  'reference_from'?: string;
-  'reference_to'?: string;
+  type?: string;
+  reference_from?: string;
+  reference_to?: string;
 }
 
 interface JsonLdOrigin {
@@ -97,6 +97,7 @@ interface JsonLdOrigin {
 }
 
 interface JsonLdSource {
+  'gl:id'?: string;
   'gl:sourceType'?: string;
   'gl:sourceStatus'?: string;
   'gl:modification'?: string;
@@ -109,6 +110,8 @@ interface JsonLdRelated {
   '@id'?: string;
   'gl:term'?: string;
   'gl:target'?: string;
+  'gl:sourceId'?: string;
+  'gl:citation'?: JsonLdOrigin;
 }
 
 interface JsonLdDesignation {
@@ -192,10 +195,24 @@ export function getRefText(ref: ConceptRef): string | null {
   return refTexts.get(ref) ?? null;
 }
 
+// RelatedConcept.sourceId: links a citation reference back to its source entry
+const relatedSourceIds = new WeakMap<object, string>();
+
+export function getRelatedSourceId(rc: object): string | null {
+  return relatedSourceIds.get(rc) ?? null;
+}
+
+// RelatedConcept.citation: embedded citation data for cite-ref references
+const relatedCitations = new WeakMap<object, Record<string, unknown>>();
+
+export function getRelatedCitation(rc: object): Record<string, unknown> | null {
+  return relatedCitations.get(rc) ?? null;
+}
+
 // Relationship types whose target is a designation string, not a concept ref.
 const DESIGNATION_REL_TYPES = new Set(['abbreviated_form_for', 'short_form_for']);
 
-function attachAnnotations(concept: Concept, localizations: Record<string, unknown>): void {
+function attachBridges(concept: Concept, localizations: Record<string, unknown>): void {
   for (const lang of concept.languages) {
     const lc = concept.localization(lang);
     const raw = localizations[lang];
@@ -210,7 +227,7 @@ function attachAnnotations(concept: Concept, localizations: Record<string, unkno
       ));
     }
 
-    // Designation-level relationship targets and ref text
+    // Designation-level relationship targets, ref text, sourceId, citation
     const rawTerms = rawObj.terms;
     if (Array.isArray(rawTerms)) {
       for (const rawTerm of rawTerms) {
@@ -222,40 +239,56 @@ function attachAnnotations(concept: Concept, localizations: Record<string, unkno
         if (!designation) continue;
         const rawRelated = rawT.related;
         if (!Array.isArray(rawRelated)) continue;
-        for (const rawRel of rawRelated) {
-          if (!rawRel || typeof rawRel !== 'object') continue;
-          const rel = rawRel as Record<string, unknown>;
-          const relType = rel.type as string | undefined;
-          const rc = designation.related.find(r => r.type === relType);
-          if (!rc) continue;
-          if (rel.target && typeof rel.target === 'string') {
-            designationTargets.set(rc as object, rel.target);
-          }
-          if ('ref' in rc && rc.ref) {
-            const rawRef = rel.ref as Record<string, unknown> | undefined;
-            if (rawRef?.text && typeof rawRef.text === 'string') {
-              refTexts.set(rc.ref, rawRef.text);
-            }
-          }
-        }
+        attachRelatedBridges(designation.related, rawRelated);
       }
     }
 
-    // Localization-level ref text
+    // Localization-level related concepts
     const rawRelated = rawObj.related;
     if (Array.isArray(rawRelated)) {
-      for (const rawRel of rawRelated) {
-        if (!rawRel || typeof rawRel !== 'object') continue;
-        const rel = rawRel as Record<string, unknown>;
-        const relType = rel.type as string | undefined;
-        const rc = relType ? lc.related.find(r => r.type === relType) : undefined;
-        if (!rc || !rc.ref) continue;
-        const rawRef = rel.ref as Record<string, unknown> | undefined;
-        if (rawRef?.text && typeof rawRef.text === 'string') {
-          refTexts.set(rc.ref, rawRef.text);
-        }
+      attachRelatedBridges(lc.related, rawRelated);
+    }
+  }
+}
+
+/**
+ * Attach bridged fields (ref text, sourceId, citation) to RelatedConcept instances
+ * from the raw deserialized data. Called after Concept.fromJSON creates the model
+ * instances, since RelatedConcept.fromJSON only reads type/content/ref.
+ */
+function attachRelatedBridges(
+  modelRelated: Array<{ type?: string | null; content?: string | null; ref?: any; related?: any[] }>,
+  rawRelated: unknown[],
+): void {
+  for (const rawRel of rawRelated) {
+    if (!rawRel || typeof rawRel !== 'object') continue;
+    const rel = rawRel as Record<string, unknown>;
+    const relType = rel.type as string | undefined;
+    const rc = relType ? modelRelated.find(r => r.type === relType) : undefined;
+    if (!rc) continue;
+
+    // Ref text
+    if (rc.ref) {
+      const rawRef = rel.ref as Record<string, unknown> | undefined;
+      if (rawRef?.text && typeof rawRef.text === 'string') {
+        refTexts.set(rc.ref, rawRef.text);
       }
     }
+
+    // Designation target
+    if (rel.target && typeof rel.target === 'string') {
+      designationTargets.set(rc, rel.target);
+    }
+
+    // Source ID — links citation reference back to the ConceptSource entry
+    if (rel.sourceId && typeof rel.sourceId === 'string') {
+      relatedSourceIds.set(rc, rel.sourceId);
+    }
+
+    // Citation — embedded origin data for cite-ref references
+    if (rel.citation && typeof rel.citation === 'object') {
+      relatedCitations.set(rc, rel.citation as Record<string, unknown>);
+    }
   }
 }
 
@@ -335,8 +368,37 @@ function mapDesignationFromJsonLd(d: JsonLdDesignation): Record<string, unknown>
   return result;
 }
 
+function mapRefFromJsonLd(rawRef: JsonLdRef | string | undefined): Record<string, unknown> | null {
+  if (!rawRef) return null;
+  if (typeof rawRef === 'string') return { source: rawRef };
+  const refObj: Record<string, unknown> = {};
+  // gl:-prefixed keys take precedence over unprefixed keys
+  refObj.source = rawRef['gl:source'] ?? rawRef.source;
+  refObj.id = rawRef['gl:id'] ?? rawRef.id;
+  refObj.version = rawRef['gl:version'] ?? rawRef.version;
+  if (rawRef['gl:text']) refObj.text = rawRef['gl:text'];
+  return (refObj.source ?? refObj.id ?? refObj.version ?? refObj.text) != null
+    ? refObj : null;
+}
+
+/**
+ * Map JSON-LD locality to glossarist's snake_case format.
+ * Always uses snake_case (reference_from/reference_to) for consistency
+ * with the glossarist model.
+ */
+function mapLocalityFromJsonLd(rawLoc: JsonLdLocality | undefined): Record<string, unknown> | null {
+  if (!rawLoc) return null;
+  const locObj: Record<string, unknown> = {};
+  locObj.type = rawLoc['gl:localityType'] ?? rawLoc.type;
+  locObj.reference_from = rawLoc['gl:referenceFrom'] ?? rawLoc.reference_from;
+  locObj.reference_to = rawLoc['gl:referenceTo'] ?? rawLoc.reference_to;
+  return (locObj.type ?? locObj.reference_from ?? locObj.reference_to) != null
+    ? locObj : null;
+}
+
 function mapSourceFromJsonLd(s: JsonLdSource): Record<string, unknown> {
   const result: Record<string, unknown> = {};
+  if (s['gl:id']) result.id = s['gl:id'];
   if (s['gl:sourceType']) result.type = s['gl:sourceType'];
   if (s['gl:sourceStatus']) result.status = s['gl:sourceStatus'];
   if (s['gl:modification']) result.modification = s['gl:modification'];
@@ -344,32 +406,10 @@ function mapSourceFromJsonLd(s: JsonLdSource): Record<string, unknown> {
   if (s['gl:origin']) {
     const origin: Record<string, unknown> = {};
     const o = s['gl:origin'];
-    if (o['gl:ref']) {
-      const rawRef = o['gl:ref'];
-      if (typeof rawRef === 'string') {
-        origin.ref = { source: rawRef };
-      } else {
-        const refObj: Record<string, unknown> = {};
-        if (rawRef['gl:source']) refObj.source = rawRef['gl:source'];
-        if (rawRef['gl:id']) refObj.id = rawRef['gl:id'];
-        if (rawRef['gl:version']) refObj.version = rawRef['gl:version'];
-        if (rawRef['source']) refObj.source = rawRef['source'];
-        if (rawRef['id']) refObj.id = rawRef['id'];
-        if (rawRef['version']) refObj.version = rawRef['version'];
-        if (Object.keys(refObj).length > 0) origin.ref = refObj;
-      }
-    }
-    if (o['gl:locality']) {
-      const loc: Record<string, unknown> = {};
-      const rawLoc = o['gl:locality'];
-      if (rawLoc['gl:localityType']) loc.type = rawLoc['gl:localityType'];
-      if (rawLoc['gl:referenceFrom']) loc.reference_from = rawLoc['gl:referenceFrom'];
-      if (rawLoc['gl:referenceTo']) loc.reference_to = rawLoc['gl:referenceTo'];
-      if (rawLoc['type']) loc.type = rawLoc['type'];
-      if (rawLoc['reference_from']) loc.reference_from = rawLoc['reference_from'];
-      if (rawLoc['reference_to']) loc.reference_to = rawLoc['reference_to'];
-      origin.locality = loc;
-    }
+    const ref = mapRefFromJsonLd(o['gl:ref']);
+    if (ref) origin.ref = ref;
+    const loc = mapLocalityFromJsonLd(o['gl:locality']);
+    if (loc) origin.locality = loc;
     if (o['gl:link']) origin.link = o['gl:link'];
     if (o['gl:id']) origin.id = o['gl:id'];
     if (o['gl:version']) origin.version = o['gl:version'];
@@ -388,14 +428,8 @@ function mapRelatedFromJsonLd(r: JsonLdRelated): Record<string, unknown> {
   }
 
   if (r['gl:ref']) {
-    const ref = r['gl:ref'];
-    const refObj: Record<string, unknown> = {};
-    if (ref['gl:source']) refObj.source = ref['gl:source'];
-    if (ref['gl:id']) refObj.id = ref['gl:id'];
-    if (ref['source']) refObj.source = ref['source'];
-    if (ref['id']) refObj.id = ref['id'];
-    if (ref['gl:text']) refObj.text = ref['gl:text'];
-    if (Object.keys(refObj).length > 0) result.ref = refObj;
+    const ref = mapRefFromJsonLd(r['gl:ref']);
+    if (ref) result.ref = ref;
   }
 
   if (!result.ref && r['@id']) {
@@ -406,6 +440,22 @@ function mapRelatedFromJsonLd(r: JsonLdRelated): Record<string, unknown> {
       : { source: uri, id: null };
   }
   if (r['gl:term']) result.content = r['gl:term'];
+
+  // Bridged fields — stored in raw dict, extracted by attachBridges()
+  if (r['gl:sourceId']) result.sourceId = r['gl:sourceId'];
+  if (r['gl:citation']) {
+    const c = r['gl:citation'];
+    const citation: Record<string, unknown> = {};
+    if (c['gl:ref']) {
+      const cr = mapRefFromJsonLd(c['gl:ref']);
+      if (cr) citation.ref = cr;
+    }
+    const loc = mapLocalityFromJsonLd(c['gl:locality']);
+    if (loc) citation.locality = loc;
+    if (c['gl:link']) citation.link = c['gl:link'];
+    if (Object.keys(citation).length > 0) result.citation = citation;
+  }
+
   return result;
 }
 
@@ -493,7 +543,7 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
     status: null,
   });
 
-  attachAnnotations(concept, localizations);
+  attachBridges(concept, localizations);
   return concept;
 }
 
@@ -505,7 +555,7 @@ export function conceptFromJson(doc: Record<string, unknown>): Concept {
   }
   const concept = Concept.fromJSON(doc);
   const locs = (doc as Record<string, unknown>).localizations as Record<string, unknown> | undefined;
-  if (locs) attachAnnotations(concept, locs);
+  if (locs) attachBridges(concept, locs);
   return concept;
 }
 

package/src/adapters/types.ts

@@ -32,6 +32,9 @@ export type {
 export { RELATIONSHIP_TYPES, DATE_TYPES } from 'glossarist';
 export { GRAMMAR_GENDERS, GRAMMAR_NUMBERS, GRAMMAR_PARTS_OF_SPEECH } from 'glossarist/models';
 
+// Re-export citation classification from ReferenceResolver (single definition site)
+export type { CitationClassification, CiteResolution } from './ReferenceResolver';
+
 // ── Dataset metadata ──────────────────────────────────────────────────────
 
 export interface ManifestSection {

package/src/components/AppSidebar.vue

@@ -114,8 +114,8 @@ const showDatasetNav = computed(() => !!currentManifest.value || !!siteConfig.va
 const provenance = computed(() => {
   const manifest = currentManifest.value;
   return {
-    owner: manifest?.owner || (siteConfig.value as any)?.branding?.ownerName,
-    ownerUrl: (siteConfig.value as any)?.branding?.ownerUrl,
+    owner: manifest?.owner || siteConfig.value?.branding?.ownerName,
+    ownerUrl: siteConfig.value?.branding?.ownerUrl,
     ref: manifest?.ref,
     status: manifest?.status,
     lastUpdated: manifest?.lastUpdated,
@@ -149,14 +149,17 @@ function isActive(page: { route: string; datasetScoped?: boolean }): boolean {
   const target = pageRoute(page);
   if (route.path === target) return true;
   if (page.datasetScoped) return route.name === page.route;
+  // Non-dataset-scoped page: only match if we're NOT inside a dataset route
+  const inDataset = 'registerId' in route.params;
+  if (inDataset) return false;
   return route.name === page.route || route.name === `${page.route}-global`;
 }
 
-function navTitle(page: { route: string }): string {
+function navTitle(page: { route: string; title?: string }): string {
   const route = page.route || 'home';
   const key = `nav.${route}`;
   const translated = t(key);
-  return translated === key ? (page as any).title : translated;
+  return translated === key ? (page.title ?? route) : translated;
 }
 
 const expandedSectionNodes = ref<Set<string>>(new Set());

package/src/components/CitationDisplay.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import type { Citation } from 'glossarist';
+import type { CitationClassification, CiteResolution } from '../adapters/types';
 import { computed, ref } from 'vue';
 import { getFactory } from '../adapters/factory';
 import { useRouter } from 'vue-router';
@@ -14,22 +15,26 @@ const router = useRouter();
 const store = useVocabularyStore();
 const factory = getFactory();
 
-function resolveCitation(): { registerId: string; conceptId: string } | null {
-  const ref = props.citation.ref;
-  const locality = props.citation.locality;
-  if (!ref?.source || !locality?.referenceFrom) return null;
+// ── Single source of truth for citation resolution ────────────────────────
+// Both classification and navigation target come from the same resolveCite()
+// call, so they can never disagree.
 
-  const resolution = factory.resolveCitation(ref.source, locality.referenceFrom, props.registerId);
-  if (!resolution || resolution.type !== 'internal') return null;
+const citeResolution = computed<CiteResolution>(() =>
+  factory.resolver.resolveCite(props.citation, props.registerId),
+);
 
-  return { registerId: resolution.registerId, conceptId: resolution.conceptId };
-}
+const classification = computed<CitationClassification>(() =>
+  citeResolution.value.classification,
+);
+
+const resolvedTarget = computed(() => citeResolution.value.resolved);
 
-const resolvedTarget = computed(() => resolveCitation());
 const isCrossDataset = computed(() =>
   resolvedTarget.value != null && resolvedTarget.value.registerId !== props.registerId,
 );
 
+// ── Navigation ────────────────────────────────────────────────────────────
+
 async function navigateToCitation() {
   if (!resolvedTarget.value) return;
   const { registerId, conceptId } = resolvedTarget.value;
@@ -37,7 +42,37 @@ async function navigateToCitation() {
   router.push({ name: 'concept', params: { registerId, conceptId } });
 }
 
-// --- Hover preview ---
+// ── Wrapper element determined by classification ──────────────────────────
+// Internal → button (navigates to concept)
+// Self-contained with link → anchor (external link)
+// Everything else → span (plain text)
+
+const sourceTag = computed(() => {
+  if (classification.value === 'internal-citation') return 'button';
+  if (classification.value === 'self-contained-citation' && props.citation.link) return 'a';
+  return 'span';
+});
+
+const sourceAttrs = computed(() => {
+  if (sourceTag.value === 'button') {
+    return { class: 'concept-link font-medium inline-flex items-center gap-0.5' };
+  }
+  if (sourceTag.value === 'a') {
+    return { href: props.citation.link!, target: '_blank', rel: 'noopener', class: 'concept-link font-medium' };
+  }
+  return { class: 'font-medium' };
+});
+
+const sourceEvents = computed(() => {
+  if (sourceTag.value !== 'button') return {};
+  return {
+    onClick: navigateToCitation,
+    onMouseenter: schedulePreview,
+  };
+});
+
+// ── Hover preview ─────────────────────────────────────────────────────────
+
 const triggerEl = ref<HTMLElement | null>(null);
 const preview = ref<{ designation: string; definition: string } | null>(null);
 const previewVisible = ref(false);
@@ -90,39 +125,60 @@ function hidePreview() {
   if (previewTimer) { clearTimeout(previewTimer); previewTimer = null; }
   previewVisible.value = false;
 }
+
+// ── Locality formatting ───────────────────────────────────────────────────
+
+function formatLocality(loc: NonNullable<Citation['locality']>): string {
+  const parts: string[] = [];
+  const lType = (loc as unknown as Record<string, unknown>).type as string | null;
+  const from = (loc as unknown as Record<string, unknown>).referenceFrom ?? (loc as unknown as Record<string, unknown>).reference_from;
+  const to = (loc as unknown as Record<string, unknown>).referenceTo ?? (loc as unknown as Record<string, unknown>).reference_to;
+  if (lType) parts.push(`, ${lType}`);
+  if (from) parts.push(to ? ` ${from}–${to}` : ` ${from}`);
+  return parts.join('');
+}
 </script>
 
 <template>
   <span class="inline" @mouseleave="hidePreview">
-    <template v-if="citation.ref">
-      <button
-        v-if="resolvedTarget"
-        @click="navigateToCitation"
-        @mouseenter="schedulePreview"
-        class="concept-link font-medium inline-flex items-center gap-0.5"
+    <!-- Source reference: dynamic wrapper (button/a/span) -->
+    <template v-if="citation.ref?.source">
+      <component
+        :is="sourceTag"
+        v-bind="sourceAttrs"
+        v-on="sourceEvents"
       >
         {{ citation.ref.source }}
         <span v-if="isCrossDataset" class="text-[10px] opacity-60 leading-none">↗</span>
-      </button>
-      <span v-else-if="citation.ref.source" class="font-medium">{{ citation.ref.source }}</span>
+      </component>
       <span v-if="citation.ref.id"> {{ citation.ref.id }}</span>
       <span v-if="citation.ref.version" class="text-ink-400"> ({{ citation.ref.version }})</span>
     </template>
+
+    <!-- Locality: same formatting across all classifications -->
     <template v-if="citation.locality">
-      <button v-if="resolvedTarget" @click="navigateToCitation" @mouseenter="schedulePreview" class="concept-link">
-        <span v-if="citation.locality.type" class="text-ink-400">, {{ citation.locality.type }}</span>
-        <span v-if="citation.locality.referenceFrom" class="text-ink-400">
-          {{ citation.locality.referenceTo ? ` ${citation.locality.referenceFrom}–${citation.locality.referenceTo}` : ` ${citation.locality.referenceFrom}` }}
-        </span>
+      <button
+        v-if="classification === 'internal-citation'"
+        @click="navigateToCitation"
+        @mouseenter="schedulePreview"
+        class="concept-link"
+      >
+        {{ formatLocality(citation.locality) }}
       </button>
-      <template v-else>
-        <span v-if="citation.locality.type" class="text-ink-400">, {{ citation.locality.type }}</span>
-        <span v-if="citation.locality.referenceFrom" class="text-ink-400">
-          {{ citation.locality.referenceTo ? ` ${citation.locality.referenceFrom}–${citation.locality.referenceTo}` : ` ${citation.locality.referenceFrom}` }}
-        </span>
-      </template>
+      <span v-else class="text-ink-400">
+        {{ formatLocality(citation.locality) }}
+      </span>
     </template>
-    <a v-if="citation.link" :href="citation.link" target="_blank" rel="noopener" class="concept-link ml-1">[link]</a>
+
+    <!-- External link badge (only for non-self-contained citations that have a link) -->
+    <a
+      v-if="citation.link && classification !== 'self-contained-citation'"
+      :href="citation.link"
+      target="_blank"
+      rel="noopener"
+      class="concept-link ml-1"
+    >[link]</a>
+
     <span v-if="citation.original" class="text-xs text-ink-300 ml-1">(orig: {{ citation.original }})</span>
     <span v-if="resolvedTarget" class="text-[9px] text-ink-300 ml-1">→ {{ resolvedTarget.registerId }}/{{ resolvedTarget.conceptId }}</span>