@glossarist/concept-browser 0.7.35 → 0.7.41

package/src/adapters/UriRouter.ts

@@ -1,34 +1,106 @@
 import type { Manifest } from './types';
 
+// ── URI pattern matching ────────────────────────────────────────────────────
+
+function matchUriPattern(uri: string, pattern: string): boolean {
+  if (!pattern.endsWith('*')) return uri === pattern;
+  return uri.startsWith(pattern.slice(0, -1));
+}
+
+function extractConceptId(uri: string, pattern: string): string | null {
+  if (!pattern.endsWith('*')) return null;
+  const base = pattern.slice(0, -1);
+  if (!uri.startsWith(base)) return null;
+  const remainder = uri.slice(base.length);
+
+  if (uri.startsWith('https://') || uri.startsWith('http://')) {
+    const match = remainder.match(/^\/?concept\/([^/?#]+)/);
+    return match ? match[1] : null;
+  }
+  if (uri.startsWith('urn:')) {
+    return remainder || null;
+  }
+  return null;
+}
+
+// ── Static parse regex ──────────────────────────────────────────────────────
+
 const URI_REGISTER_RE = /\/([^/]+)\/concept\/([^/]+)$/;
 
+// ── UriRouter ───────────────────────────────────────────────────────────────
+
+/**
+ * Single source of truth for URI routing.
+ *
+ * Maps URIs to {registerId, conceptId} pairs using dataset-registered URI
+ * patterns. Supports wildcard patterns, URN prefix mapping, and URI construction.
+ *
+ * ReferenceResolver delegates URI matching here and adds its own concerns
+ * (routing table, source refs, citation classification) on top.
+ */
 export class UriRouter {
-  private registerMap = new Map<string, { baseUrl: string; manifest: Manifest | null; uriBase: string }>();
+  /** registerId → { baseUrl, uriBase, uriPatterns } */
+  private registerMap = new Map<string, { baseUrl: string; uriBase: string; uriPatterns: string[] }>();
 
-  registerDataset(registerId: string, baseUrl: string, manifest?: Manifest) {
-    this.registerMap.set(registerId, {
-      baseUrl,
-      manifest: manifest ?? null,
-      uriBase: manifest?.uriBase ?? '',
-    });
+  /** URN prefix → registerId (extracted from uriPatterns at registration time) */
+  private urnMap = new Map<string, string>();
+
+  /**
+   * Register a dataset's URI patterns for routing.
+   * URN-prefixed patterns are also indexed for fast URN → registerId lookup.
+   */
+  registerDataset(registerId: string, baseUrl: string, uriBase: string, uriPatterns: string[]): void {
+    this.registerMap.set(registerId, { baseUrl, uriBase, uriPatterns });
+
+    for (const pattern of uriPatterns) {
+      const base = pattern.endsWith('*') ? pattern.slice(0, -1) : pattern;
+      if (base.startsWith('urn:')) {
+        // Store without trailing colon so prefix matching works naturally
+        const clean = base.endsWith(':') ? base.slice(0, -1) : base;
+        this.urnMap.set(clean, registerId);
+      }
+    }
   }
 
+  /**
+   * Resolve a URI to {registerId, conceptId} using registered patterns.
+   * Returns null if no registered dataset matches.
+   */
   resolveUri(uri: string): { registerId: string; conceptId: string } | null {
     for (const [registerId, info] of this.registerMap) {
-      const prefix = `${info.uriBase}/${registerId}/concept/`;
-      if (uri.startsWith(prefix)) {
-        return { registerId, conceptId: uri.slice(prefix.length) };
+      for (const pattern of info.uriPatterns) {
+        if (matchUriPattern(uri, pattern)) {
+          const conceptId = extractConceptId(uri, pattern);
+          if (conceptId) return { registerId, conceptId };
+        }
       }
     }
     return null;
   }
 
+  /** Resolve a URN prefix to a registerId. Matches by longest prefix. Returns null if unknown. */
+  resolveUrn(urn: string): string | null {
+    // Try exact match first, then progressively shorter prefixes
+    for (let len = urn.length; len > 0; len--) {
+      const prefix = urn.slice(0, len);
+      const match = this.urnMap.get(prefix);
+      if (match) return match;
+    }
+    return null;
+  }
+
+  /** Get the uriBase for a register. Returns empty string if unknown. */
+  getUriBase(registerId: string): string {
+    return this.registerMap.get(registerId)?.uriBase ?? '';
+  }
+
   /** Extract registerId and conceptId from any glossarist URI (no registration needed). */
   static parseUri(uri: string): { registerId: string; conceptId: string } | null {
     const m = uri.match(URI_REGISTER_RE);
     return m ? { registerId: m[1], conceptId: m[2] } : null;
   }
 
+  /** Construct a canonical URI for a concept. */
   buildUri(registerId: string, conceptId: string): string {
     const info = this.registerMap.get(registerId);
     const uriBase = info?.uriBase ?? '';

package/src/adapters/factory.ts

@@ -2,15 +2,17 @@ import type { DatasetRegistry, Manifest, Resolution } from './types';
 import type { RoutingEntry as ConfigRoutingEntry } from '../config/types';
 import { DatasetAdapter } from './DatasetAdapter';
 import { ReferenceResolver } from './ReferenceResolver';
+import { UriRouter } from './UriRouter';
 
 export class AdapterFactory {
   private adapters = new Map<string, DatasetAdapter>();
-  private urnMap = new Map<string, string>();
-  readonly resolver: ReferenceResolver;
   private crossRefIndex: Record<string, string[]> | null = null;
+  readonly uriRouter: UriRouter;
+  readonly resolver: ReferenceResolver;
 
   constructor() {
-    this.resolver = new ReferenceResolver();
+    this.uriRouter = new UriRouter();
+    this.resolver = new ReferenceResolver(this.uriRouter);
   }
 
   async discoverDatasets(datasetsUrl: string): Promise<DatasetAdapter[]> {
@@ -79,16 +81,38 @@ export class AdapterFactory {
       ...(manifest.uriAliases ?? []),
       manifest.uriBase ? `${manifest.uriBase}/${registerId}/*` : undefined,
     ].filter(Boolean) as string[];
-    this.resolver.registerDataset(registerId, uriPatterns);
 
-    if (manifest.datasetUri) this.urnMap.set(manifest.datasetUri, registerId);
-    for (const alias of manifest.uriAliases ?? []) {
-      const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
-      if (base.startsWith('urn:')) this.urnMap.set(base, registerId);
+    this.uriRouter.registerDataset(
+      registerId,
+      manifest.baseUrl,
+      manifest.uriBase,
+      uriPatterns,
+    );
+
+    // Propagate URN map to all adapters for ref-target resolution
+    const urnMap = new Map<string, string>();
+    for (const id of this.uriRouter.getRegisteredIds()) {
+      const uriBase = this.uriRouter.getUriBase(id);
+      if (!uriBase) continue;
+      // Reconstruct URN map from uriRouter registrations
+      for (const pattern of [manifest.datasetUri, ...(manifest.uriAliases ?? [])]) {
+        if (!pattern) continue;
+        const base = pattern.endsWith('*') ? pattern.slice(0, -1) : pattern;
+        if (base.startsWith('urn:')) urnMap.set(base, registerId);
+      }
+    }
+    // Include URNs from all previously registered datasets
+    for (const adapter of this.adapters.values()) {
+      const m = adapter.manifest;
+      if (!m) continue;
+      for (const pattern of [m.datasetUri, ...(m.uriAliases ?? [])]) {
+        if (!pattern) continue;
+        const base = pattern.endsWith('*') ? pattern.slice(0, -1) : pattern;
+        if (base.startsWith('urn:')) urnMap.set(base, adapter.registerId);
+      }
     }
-
     for (const adapter of this.adapters.values()) {
-      adapter.setUrnMap(this.urnMap);
+      adapter.setUrnMap(urnMap);
     }
   }
 

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());