@glossarist/concept-browser 0.7.30 → 0.7.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.30",
+  "version": "0.7.32",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {

package/scripts/build-edges.js

@@ -23,6 +23,32 @@ function slugify(text) {
 
 // --- Extractors (open/closed: add new extractors to EXTRACTORS array) ---
 
+function extractSourceRefs(concept, registerId) {
+  const refs = new Set();
+
+  // Managed concept-level sources
+  for (const src of concept['gl:source'] || []) {
+    const origin = src['gl:origin'];
+    if (origin) {
+      const ref = origin['gl:ref'];
+      if (ref?.['gl:source']) refs.add(ref['gl:source']);
+    }
+  }
+
+  // Localized concept-level sources
+  for (const lc of Object.values(concept['gl:localizedConcept'] || {})) {
+    for (const src of lc['gl:source'] || []) {
+      const origin = src['gl:origin'];
+      if (origin) {
+        const ref = origin['gl:ref'];
+        if (ref?.['gl:source']) refs.add(ref['gl:source']);
+      }
+    }
+  }
+
+  return [...refs].map(source => ({ source, registerId }));
+}
+
 function extractReferences(concept, registerId) {
   const edges = [];
   const sourceUri = concept['@id'];
@@ -129,13 +155,14 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
   const conceptsDir = join(datasetDir, 'concepts');
   if (!existsSync(conceptsDir)) {
     console.log(`  Skipping ${registerId}: no concepts directory`);
-    return [];
+    return { edges: [], sourceRefs: [] };
   }
 
   const files = readdirSync(conceptsDir).filter(f => f.endsWith('.json'));
   console.log(`  Processing ${files.length} concepts...`);
 
   const allEdges = [];
+  const allSourceRefs = [];
   const domainConceptCount = new Map();
   let processed = 0;
 
@@ -144,6 +171,7 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
       const data = JSON.parse(readFileSync(join(conceptsDir, file), 'utf-8'));
       const edges = extractAllEdges(data, registerId, uriBase, urnMap);
       allEdges.push(...edges);
+      allSourceRefs.push(...extractSourceRefs(data, registerId));
 
       for (const edge of edges) {
         if (edge.type === 'domain' || edge.type === 'section') {
@@ -241,7 +269,7 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
     console.log(`  Written ${domainNodes.length} edge-derived domain nodes to domain-nodes.json`);
   }
 
-  return deduped;
+  return { edges: deduped, sourceRefs: allSourceRefs };
 }
 
 // Main
@@ -278,6 +306,7 @@ for (const ds of datasets) {
 console.log(`URN resolution map: ${[...urnMap.entries()].map(([k,v]) => `${k}→${v}`).join(', ')}\n`);
 
 const allDatasetEdges = new Map();
+const allSourceRefs = [];
 
 for (const ds of datasets) {
   const manifest = manifestCache.get(ds);
@@ -285,14 +314,44 @@ for (const ds of datasets) {
   try {
     console.log(`${manifest.title} (${ds}):`);
     const uriBase = manifest.uriBase || 'https://glossarist.org';
-    const edges = buildEdgesForDataset(join(DATA_DIR, ds), ds, uriBase, urnMap, manifest);
-    allDatasetEdges.set(ds, edges);
+    const result = buildEdgesForDataset(join(DATA_DIR, ds), ds, uriBase, urnMap, manifest);
+    allDatasetEdges.set(ds, result.edges);
+    allSourceRefs.push(...result.sourceRefs);
   } catch (e) {
     console.error(`Error reading manifest for ${ds}: ${e.message}`);
   }
   console.log();
 }
 
+// Build source-refs index: maps every source string to its dataset ID.
+// Uses manifest ref/refAliases as authoritative keys, augmented by
+// actual source strings found in concept data.
+const sourceRefMap = {};
+
+// Seed from manifests (authoritative)
+for (const [ds, manifest] of manifestCache) {
+  if (manifest.ref) sourceRefMap[manifest.ref] = ds;
+  for (const alias of manifest.refAliases ?? []) {
+    sourceRefMap[alias] = ds;
+  }
+  if (manifest.datasetUri) sourceRefMap[manifest.datasetUri] = ds;
+  for (const alias of manifest.uriAliases ?? []) {
+    const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
+    sourceRefMap[base] = ds;
+  }
+}
+
+// Augment with actual source strings from concepts
+for (const { source, registerId } of allSourceRefs) {
+  if (!sourceRefMap[source]) {
+    sourceRefMap[source] = registerId;
+  }
+}
+
+const sourceRefPath = join(DATA_DIR, 'source-refs.json');
+writeFileSync(sourceRefPath, JSON.stringify(sourceRefMap));
+console.log(`Written source-refs.json (${Object.keys(sourceRefMap).length} source references across ${datasets.length} datasets)\n`);
+
 // Build cross-reference index: for each dataset, which other datasets'
 // edges.json contains edges targeting that dataset's URIs.
 const datasetUriPrefixes = new Map();

package/src/__tests__/designation-relationship.test.ts

@@ -42,7 +42,7 @@ describe('designation relationship bridge', () => {
 
     const rc = term.related[0];
     expect(rc.type).toBe('abbreviated_form_for');
-    expect(getDesignationTarget(rc)).toBe('Portable Document Format');
+    expect(getDesignationTarget(rc as any)).toBe('Portable Document Format');
   });
 
   it('returns null for concept-level relationships (no target)', () => {
@@ -50,7 +50,7 @@ describe('designation relationship bridge', () => {
     const concept = conceptFromJson(doc);
     const rc = concept.localization('eng')!.terms[0].related[0];
     expect(rc.type).toBe('abbreviated_form_for');
-    expect(getDesignationTarget(rc)).toBeNull();
+    expect(getDesignationTarget(rc as any)).toBeNull();
   });
 
   it('handles short_form_for designation target', () => {
@@ -58,7 +58,7 @@ describe('designation relationship bridge', () => {
     const concept = conceptFromJson(doc);
     const rc = concept.localization('eng')!.terms[0].related[0];
     expect(rc.type).toBe('short_form_for');
-    expect(getDesignationTarget(rc)).toBe('kilogram');
+    expect(getDesignationTarget(rc as any)).toBe('kilogram');
   });
 
   it('preserves designation target from glossarist native format', () => {
@@ -78,7 +78,7 @@ describe('designation relationship bridge', () => {
     };
     const concept = conceptFromJson(doc);
     const rc = concept.localization('eng')!.terms[0].related[0];
-    expect(getDesignationTarget(rc)).toBe('Portable Document Format');
+    expect(getDesignationTarget(rc as any)).toBe('Portable Document Format');
   });
 
   it('designation without related returns empty related array', () => {

package/src/__tests__/factory-lazy.test.ts

@@ -56,8 +56,8 @@ describe('AdapterFactory — lazy discovery', () => {
     expect(adapters[0].manifest).not.toBeNull();
     expect(adapters[0].manifest!.title).toBe('Dataset 1');
     expect(adapters[0].manifest!.conceptCount).toBe(100);
-    // Should NOT fetch manifest.json — only datasets.json
-    expect(mockFetch).toHaveBeenCalledTimes(1);
+    // Should NOT fetch manifest.json — only datasets.json + source-refs.json
+    expect(mockFetch).toHaveBeenCalledTimes(2);
     expect(mockFetch).toHaveBeenCalledWith('/datasets.json');
   });
 
@@ -89,8 +89,8 @@ describe('AdapterFactory — lazy discovery', () => {
 
     expect(adapters.length).toBe(1);
     expect(adapters[0].manifest!.title).toBe('Full Dataset');
-    // Should fetch both datasets.json and manifest.json
-    expect(mockFetch).toHaveBeenCalledTimes(2);
+    // Should fetch datasets.json, manifest.json, and source-refs.json
+    expect(mockFetch).toHaveBeenCalledTimes(3);
   });
 
   it('loads full manifest in loadDataset after summary discovery', async () => {
@@ -140,10 +140,10 @@ describe('AdapterFactory — lazy discovery', () => {
       return Promise.resolve({ ok: false, status: 404 } as Response);
     });
 
-    // Discover with summary — no manifest fetch
+    // Discover with summary — no manifest fetch (datasets.json + source-refs.json)
     const adapters = await factory.discoverDatasets('/datasets.json');
     expect(adapters[0].manifest!.title).toBe('Summary Title');
-    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).toHaveBeenCalledTimes(2);
 
     // Load full dataset — fetches full manifest + index
     const loaded = await factory.loadDataset('ds1');

package/src/__tests__/source-refs.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ReferenceResolver } from '../adapters/ReferenceResolver';
+import type { Resolution } from '../adapters/types';
+
+type InternalResolution = Extract<Resolution, { type: 'internal' }>;
+
+function asInternal(r: Resolution | null): InternalResolution | null {
+  return r?.type === 'internal' ? (r as InternalResolution) : null;
+}
+
+describe('Source reference resolution (citation linking)', () => {
+  let resolver: ReferenceResolver;
+
+  beforeEach(() => {
+    resolver = new ReferenceResolver();
+    // Register datasets with URI patterns
+    resolver.registerDataset('vim-2012', ['urn:oiml:pub:v:2:2012*']);
+    resolver.registerDataset('viml-2022', ['urn:oiml:pub:v:1:2022*']);
+    resolver.registerDataset('vim-2007', ['urn:oiml:pub:v:2:2007*']);
+  });
+
+  describe('registerSourceRef', () => {
+    it('resolves citation when source ref matches exactly', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+
+    it('resolves citation using variant source string', () => {
+      // Manifest has "OIML V 2-200:2012" but concepts use "OIML V2-200:2012"
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      resolver.registerSourceRef('OIML V2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+      const result = resolver.resolveCitation('OIML V2-200:2012', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+
+    it('resolves citation using URN as source', () => {
+      resolver.registerSourceRef('urn:oiml:pub:v:2:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('urn:oiml:pub:v:2:2012', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+
+    it('resolves citation using ref alias (e.g. "VIM")', () => {
+      resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('VIM', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+
+    it('returns null when source ref is not registered', () => {
+      const result = resolver.resolveCitation('Unknown Source', '2.2', 'viml-2022');
+      expect(result).toBeNull();
+    });
+
+    it('returns null when source ref matches but concept does not exist in dataset', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      // The resolver can only check if the dataset exists, not if the concept exists
+      // It will still return internal if the dataset is registered
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '99.99', 'viml-2022');
+      expect(result?.type).toBe('internal');
+    });
+
+    it('handles same-dataset citation (crossDataset=false)', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '2.2', 'vim-2012');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: false,
+      });
+    });
+  });
+
+  describe('resolveCitation fallback to URN', () => {
+    it('resolves URN-based source without registerSourceRef', () => {
+      // When source starts with "urn:", tryResolveCitationUri handles it
+      const result = resolver.resolveCitation('urn:oiml:pub:v:2:2012', '2.2', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '2.2',
+        crossDataset: true,
+      });
+    });
+  });
+
+  describe('multiple source strings for same dataset', () => {
+    it('registers multiple source refs pointing to the same dataset', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      resolver.registerSourceRef('OIML V2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      resolver.registerSourceRef('VIM', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      resolver.registerSourceRef('ISO Guide 99:2007', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+      expect(asInternal(resolver.resolveCitation('OIML V 2-200:2012', '2.2'))?.registerId).toBe('vim-2012');
+      expect(asInternal(resolver.resolveCitation('OIML V2-200:2012', '2.2'))?.registerId).toBe('vim-2012');
+      expect(asInternal(resolver.resolveCitation('VIM', '2.2'))?.registerId).toBe('vim-2012');
+      expect(asInternal(resolver.resolveCitation('ISO Guide 99:2007', '2.2'))?.registerId).toBe('vim-2012');
+    });
+  });
+
+  describe('ISO source references', () => {
+    it('resolves ISO/IEC references when registered', () => {
+      resolver.registerDataset('iso-17000', ['urn:iso:std:iso:iec:17000*']);
+      resolver.registerSourceRef('ISO/IEC 17000:2020', 'iso-17000', 'urn:iso:std:iso:iec:17000');
+
+      const result = resolver.resolveCitation('ISO/IEC 17000:2020', '3.1', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'iso-17000',
+        conceptId: '3.1',
+        crossDataset: true,
+      });
+    });
+
+    it('returns null for unresolvable ISO references', () => {
+      // ISO dataset not loaded — no registerSourceRef or dataset pattern match
+      const result = resolver.resolveCitation('ISO/IEC 17000:2020', '3.1', 'viml-2022');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns internal with empty conceptId when referenceFrom is empty', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '');
+      // Resolver still resolves but with empty conceptId — UI handles this
+      expect(result?.type).toBe('internal');
+    });
+
+    it('handles concept IDs with dots', () => {
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+      const result = resolver.resolveCitation('OIML V 2-200:2012', '5.12.3', 'viml-2022');
+      expect(result).toEqual({
+        type: 'internal',
+        registerId: 'vim-2012',
+        conceptId: '5.12.3',
+        crossDataset: true,
+      });
+    });
+
+    it('handles source strings with special characters', () => {
+      resolver.registerDataset('vim-1993', ['urn:oiml:pub:v:2:1993*']);
+      resolver.registerSourceRef('OIML V 2:1993', 'vim-1993', 'urn:oiml:pub:v:2:1993');
+      const result = resolver.resolveCitation('OIML V 2:1993', '3.6');
+      expect(asInternal(result)?.registerId).toBe('vim-1993');
+    });
+
+    it('does not confuse similar source strings', () => {
+      resolver.registerSourceRef('OIML V 2-200:2007', 'vim-2007', 'urn:oiml:pub:v:2:2007');
+      resolver.registerSourceRef('OIML V 2-200:2012', 'vim-2012', 'urn:oiml:pub:v:2:2012');
+
+      const result2007 = resolver.resolveCitation('OIML V 2-200:2007', '2.2');
+      const result2012 = resolver.resolveCitation('OIML V 2-200:2012', '2.2');
+
+      expect(asInternal(result2007)?.registerId).toBe('vim-2007');
+      expect(asInternal(result2012)?.registerId).toBe('vim-2012');
+    });
+  });
+});

package/src/adapters/factory.ts

@@ -56,6 +56,9 @@ export class AdapterFactory {
       adapter.setUrnMap(this.urnMap);
     }
 
+    // Load source-refs index for citation resolution
+    await this.loadSourceRefs();
+
     return adapters;
 
   }
@@ -154,6 +157,21 @@ export class AdapterFactory {
     this.crossRefIndex = this.crossRefIndex || {};
     return this.crossRefIndex;
   }
+
+  async loadSourceRefs(): Promise<void> {
+    try {
+      const resp = await fetch(`${import.meta.env.BASE_URL}data/source-refs.json`);
+      if (!resp.ok) return;
+      const refs: Record<string, string> = await resp.json();
+      for (const [source, datasetId] of Object.entries(refs)) {
+        const adapter = this.adapters.get(datasetId);
+        if (!adapter?.manifest) continue;
+        this.resolver.registerSourceRef(source, datasetId, adapter.manifest.datasetUri);
+      }
+    } catch {
+      // source-refs.json is optional
+    }
+  }
 }
 
 let _instance: AdapterFactory | null = null;

package/src/adapters/model-bridge.ts

@@ -221,13 +221,15 @@ function attachAnnotations(concept: Concept, localizations: Record<string, unkno
         for (let j = 0; j < designation.related.length && j < rawRelated.length; j++) {
           const rawRel = rawRelated[j] as Record<string, unknown>;
           const rc = designation.related[j];
-          if (rawRel.target && typeof rawRel.target === 'string') {
-            designationTargets.set(rc, rawRel.target);
-          }
-          if (rc.ref) {
-            const rawRef = rawRel.ref as Record<string, unknown> | undefined;
-            if (rawRef?.text && typeof rawRef.text === 'string') {
-              refTexts.set(rc.ref, rawRef.text);
+          if ('type' in rc) {
+            if (rawRel.target && typeof rawRel.target === 'string') {
+              designationTargets.set(rc as RelatedConcept, rawRel.target);
+            }
+            if ('ref' in rc && rc.ref) {
+              const rawRef = rawRel.ref as Record<string, unknown> | undefined;
+              if (rawRef?.text && typeof rawRef.text === 'string') {
+                refTexts.set((rc as RelatedConcept).ref!, rawRef.text);
+              }
             }
           }
         }

package/src/components/ConceptDetail.vue

@@ -314,8 +314,18 @@ const conceptUriValue = computed(() =>
   conceptUri(props.concept, props.registerId, props.manifest.uriBase)
 );
 
-const outgoingEdges = computed(() => props.edges.filter(e => e.source === conceptUriValue.value && e.type !== 'domain' && e.type !== 'section'));
-const incomingEdges = computed(() => props.edges.filter(e => e.target === conceptUriValue.value && e.type !== 'domain' && e.type !== 'section'));
+const outgoingEdges = computed(() => dedupeEdges(props.edges.filter(e => e.source === conceptUriValue.value && e.type !== 'domain' && e.type !== 'section'), 'target'));
+const incomingEdges = computed(() => dedupeEdges(props.edges.filter(e => e.target === conceptUriValue.value && e.type !== 'domain' && e.type !== 'section'), 'source'));
+
+function dedupeEdges(edges: GraphEdge[], direction: 'source' | 'target'): GraphEdge[] {
+  const seen = new Set<string>();
+  return edges.filter(e => {
+    const key = `${e[direction]}\0${e.type}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
 
 function inverseEdgeType(type: string): string {
   return INVERSE_RELATIONSHIPS[type] || type;

package/src/components/DesignationList.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import type { Designation, Expression, ConceptSource } from 'glossarist';
+import type { Designation, Expression, ConceptSource, RelatedConcept } from 'glossarist';
 import { designationTypeInfo, normativeStatusInfo, abbreviationDetails, termTypeInfo, grammarBadges, pronunciationLabel, pronunciationTooltip, sourceTypeInfo } from '../utils/designation-registry';
 import { relationshipLabel } from '../utils/relationship-categories';
 import { langName } from '../utils/lang';
@@ -17,6 +17,10 @@ const emit = defineEmits<{
   (e: 'navigate-related', ref: { source: string | null; id: string | null }): void;
 }>();
 
+function asRelated(dr: unknown): RelatedConcept | null {
+  return dr && typeof dr === 'object' && 'ref' in dr ? dr as RelatedConcept : null;
+}
+
 function resolvedLabel(dr: { content: string | null; ref: { source: string | null; id: string | null } | null }): string {
   if (dr.content) return dr.content;
   if (dr.ref?.source && dr.ref?.id) return `${dr.ref.source}/${dr.ref.id}`;
@@ -65,12 +69,12 @@ function resolvedLabel(dr: { content: string | null; ref: { source: string | nul
       </div>
       <div v-if="d.related?.length" class="mt-0.5 space-y-0.5">
         <div v-for="(dr, dri) in d.related" :key="'dr'+dri" class="text-xs text-ink-400 flex items-center gap-1.5">
-          <span class="badge text-[9px] bg-gray-50 text-gray-600">{{ relationshipLabel(dr.type) }}</span>
-          <template v-if="getDesignationTarget(dr)">
-            <span class="italic">{{ getDesignationTarget(dr) }}</span>
+          <span class="badge text-[9px] bg-gray-50 text-gray-600">{{ relationshipLabel(dr.type as string) }}</span>
+          <template v-if="getDesignationTarget(dr as any)">
+            <span class="italic">{{ getDesignationTarget(dr as any) }}</span>
           </template>
-          <button v-else-if="dr.ref" @click="emit('navigate-related', dr.ref)" class="concept-link">{{ resolvedLabel(dr) }}</button>
-          <span v-else>{{ resolvedLabel(dr) }}</span>
+          <button v-else-if="asRelated(dr)?.ref" @click="emit('navigate-related', asRelated(dr)!.ref!)" class="concept-link">{{ resolvedLabel(asRelated(dr)!) }}</button>
+          <span v-else>{{ resolvedLabel(dr as any) }}</span>
         </div>
       </div>
     </div>