@glossarist/concept-browser 0.7.62 → 0.7.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.62",
+  "version": "0.7.64",
   "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

@@ -49,7 +49,8 @@ function extractReferences(concept, registerId) {
 }
 
 function extractDomains(concept, registerId, uriBase) {
-  const base = uriBase || 'https://glossarist.org';
+  if (!uriBase) throw new Error('build-edges: uriBase is required — set uriBase in site-config.yml');
+  const base = uriBase;
   const edges = [];
   const sourceUri = concept['@id'];
   const seen = new Set();
@@ -188,7 +189,8 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
   // Build domain-nodes.json from manifest sections (authoritative source)
   const manifestSections = manifest.sections;
   if (manifestSections && manifestSections.length > 0) {
-    const uriBase = manifest.uriBase || 'https://glossarist.org';
+    const uriBase = manifest.uriBase;
+    if (!uriBase) throw new Error('build-edges: manifest.uriBase is required');
 
     function buildSectionNode(section, idx) {
       const sectionId = `section-${section.id}`;
@@ -293,7 +295,8 @@ for (const ds of datasets) {
   if (!manifest) continue;
   try {
     console.log(`${manifest.title} (${ds}):`);
-    const uriBase = manifest.uriBase || 'https://glossarist.org';
+    const uriBase = manifest.uriBase;
+    if (!uriBase) throw new Error('build-edges: manifest.uriBase is required');
     const result = buildEdgesForDataset(join(DATA_DIR, ds), ds, uriBase, urnMap, manifest);
     allDatasetEdges.set(ds, result.edges);
     allSourceRefs.push(...result.sourceRefs);
@@ -347,7 +350,8 @@ if (auditUnmatched.size > 0) {
 // edges.json contains edges targeting that dataset's URIs.
 const datasetUriPrefixes = new Map();
 for (const [ds, manifest] of manifestCache) {
-  const uriBase = manifest.uriBase || 'https://glossarist.org';
+  const uriBase = manifest.uriBase;
+    if (!uriBase) throw new Error('build-edges: manifest.uriBase is required');
   datasetUriPrefixes.set(ds, `${uriBase}/${ds}/`);
 }
 

package/scripts/generate-data.mjs

@@ -92,7 +92,8 @@ function writeJson(filePath, data) {
 }
 
 async function writeDatasetRdf(register, manifest, concepts, refMaps, opts) {
-  const uriBase = refMaps?.uriBase ?? 'https://glossarist.org';
+  const uriBase = refMaps?.uriBase;
+  if (!uriBase) throw new Error('generate-data: uriBase is required — set uriBase in site-config.yml');
   const datasetIri = `${uriBase}/${register}/`;
   const topConceptUris = concepts
     .slice(0, 32)
@@ -375,7 +376,8 @@ function buildRefMaps(config, registerCache) {
   const xref = config.crossReferences || {};
   if (xref.refPrefixMap) Object.assign(refPrefixMap, xref.refPrefixMap);
 
-  const uriBase = config.uriBase || `https://${config.domain}`;
+  const uriBase = config.uriBase;
+  if (!uriBase) throw new Error('site-config.yml: uriBase is required');
   return { patternIndex, refPrefixMap, uriBase, register: null };
 }
 
@@ -1617,7 +1619,7 @@ console.log('Emitted vocabulary graph: data/_vocab.ttl');
 
 const contributors = config.contributors ?? [];
 if (contributors.length > 0) {
-  fs.writeFileSync(path.join(DATA, 'agents.ttl'), await buildAgentsTurtle(contributors));
+  fs.writeFileSync(path.join(DATA, 'agents.ttl'), await buildAgentsTurtle(contributors, refMaps.uriBase + '/agent'));
   console.log(`Emitted agents graph: data/agents.ttl (${contributors.length} contributors)`);
 }
 
@@ -1626,7 +1628,7 @@ for (const ds of registry) {
   const bibPath = path.join(DATA, ds.id, 'bibliography.json');
   if (fs.existsSync(bibPath)) {
     const bibJson = JSON.parse(fs.readFileSync(bibPath, 'utf8'));
-    const bibTtl = await buildBibliographyTurtle(ds.id, bibJson);
+    const bibTtl = await buildBibliographyTurtle(ds.id, bibJson, refMaps.uriBase);
     fs.writeFileSync(path.join(DATA, ds.id, 'bib.ttl'), bibTtl);
   }
 }

package/scripts/lib/agents-turtle.mjs

@@ -19,7 +19,8 @@ function writerPrefixes() {
   };
 }
 
-export async function buildAgentsTurtle(contributors, agentBase = 'https://glossarist.org/agent') {
+export async function buildAgentsTurtle(contributors, agentBase) {
+  if (!agentBase) throw new Error('buildAgentsTurtle requires agentBase');
   const agents = agentsFromContributors(contributors ?? [], agentBase);
   const quads = collectQuads(agentsToQuads(agents));
   return writeTurtle(quads, { prefixes: writerPrefixes() });

package/scripts/lib/bibliography-turtle.mjs

@@ -10,7 +10,7 @@ import {
   writeTurtle,
 } from 'glossarist/rdf';
 
-const DEFAULT_BASE_URI = 'https://glossarist.org';
+// No hardcoded default base URI — callers MUST pass it.
 
 function writerPrefixes() {
   return {
@@ -22,7 +22,8 @@ function writerPrefixes() {
 
 export { normalizeBibliographyData };
 
-export async function buildBibliographyTurtle(register, bibliographyJson, baseUri = DEFAULT_BASE_URI) {
+export async function buildBibliographyTurtle(register, bibliographyJson, baseUri) {
+  if (!baseUri) throw new Error('buildBibliographyTurtle requires baseUri');
   const entries = normalizeBibliographyData(bibliographyJson);
   const quads = collectQuads(bibliographyToQuads({ registerId: register, entries, baseUri }));
   return writeTurtle(quads, { prefixes: writerPrefixes() });

package/src/__tests__/dataset-adapter.test.ts

@@ -19,6 +19,7 @@ describe('DatasetAdapter', () => {
 
   beforeEach(() => {
     adapter = new DatasetAdapter('test', '/data/test');
+    adapter.manifest = { uriBase: 'https://glossarist.org' } as any;
     mockFetch.mockReset();
   });
 

package/src/__tests__/relation-sphere-uri.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { UriRouter } from '../adapters/UriRouter';
+
+describe('UriRouter.parseUri — deployment-agnostic concept URI parsing', () => {
+  // The old parseNeighborUri in RelationSphere.vue hardcoded specific
+  // hostnames. UriRouter.parseUri must work for ANY deployment.
+  const cases: Array<[string, string, string]> = [
+    // [input URI, expected registerId, expected conceptId]
+    ['https://www.glossarist.org/iala-vocab/iala-2022/concept/1-1-000',     'iala-2022', '1-1-000'],
+    ['https://glossarist.org/iala-2022/concept/1-1-000',                    'iala-2022', '1-1-000'],
+    ['https://glossarist.org/iso/concept/3.1.1',                            'iso',       '3.1.1'],
+    ['https://oimlsmart.github.io/vocab/viml-2022/concept/1.1',             'viml-2022', '1.1'],
+    ['https://www.oimlsmart.org/vocab/viml-2022/concept/1.1',               'viml-2022', '1.1'],
+    ['https://metanorma.github.io/iala-vocab/iala-2023/concept/2-1-245',    'iala-2023', '2-1-245'],
+    ['https://isotc204.geolexica.org/isotc204-2022/concept/3.5.8.8',       'isotc204-2022', '3.5.8.8'],
+    ['https://vocab.example.org/dataset-x/concept/foo',                      'dataset-x', 'foo'],
+    ['https://custom.host/path/to/register/concept/abc-123',                'register',  'abc-123'],
+  ];
+
+  for (const [uri, expectedReg, expectedId] of cases) {
+    it(`parses ${uri}`, () => {
+      const parsed = UriRouter.parseUri(uri);
+      expect(parsed).toEqual({ registerId: expectedReg, conceptId: expectedId });
+    });
+  }
+
+  it('returns null for URIs without /concept/', () => {
+    expect(UriRouter.parseUri('https://example.org/foo/bar')).toBeNull();
+    expect(UriRouter.parseUri('urn:iso:std:iso:14812:2025:3.5.8.8')).toBeNull();
+    expect(UriRouter.parseUri('')).toBeNull();
+  });
+
+  it('does NOT hardcode any specific hostname', () => {
+    // Every deployment domain should work. If the regex hardcodes
+    // a specific host, this test would fail for others.
+    const diverse = [
+      'https://a.io/r/concept/1',
+      'https://b.com/x/y/z/concept/2',
+      'https://1.2.3.4/reg/concept/3',
+    ];
+    for (const uri of diverse) {
+      expect(UriRouter.parseUri(uri)).not.toBeNull();
+    }
+  });
+});

package/src/__tests__/scripts/agents-turtle.test.ts

@@ -16,13 +16,13 @@ const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
 
 describe('buildAgentsTurtle (mjs)', () => {
   it('parses without errors', async () => {
-    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }]);
+    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }], 'https://glossarist.org/agent');
     const store = parse(ttl);
     expect(store.size).toBeGreaterThan(0);
   });
 
   it('types each person as foaf:Person, prov:Person, prov:Agent', async () => {
-    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }]);
+    const ttl = await buildAgentsTurtle([{ name: 'Ada Lovelace' }], 'https://glossarist.org/agent');
     const store = parse(ttl);
     const types = store.getObjects('https://glossarist.org/agent/ada-lovelace', RDF_TYPE, null).map(q => q.value);
     expect(types).toContain(`${FOAF}Person`);
@@ -33,7 +33,7 @@ describe('buildAgentsTurtle (mjs)', () => {
   it('records name, mailto mbox, role, and seeAlso', async () => {
     const ttl = await buildAgentsTurtle([
       { name: 'Ada Lovelace', email: 'ada@example.org', role: 'Editor', url: 'https://example.org/ada' },
-    ]);
+    ], 'https://glossarist.org/agent');
     const store = parse(ttl);
     const iri = 'https://glossarist.org/agent/ada-lovelace';
     expect(store.getObjects(iri, `${FOAF}name`, null).map(q => q.value)).toContain('Ada Lovelace');
@@ -46,7 +46,7 @@ describe('buildAgentsTurtle (mjs)', () => {
     const ttl = await buildAgentsTurtle([
       { name: 'Alice', organization: 'ISO' },
       { name: 'Bob',   organization: 'ISO' },
-    ]);
+    ], 'https://glossarist.org/agent');
     const store = parse(ttl);
     const types = store.getObjects('https://glossarist.org/org/iso', RDF_TYPE, null).map(q => q.value);
     expect(types).toContain(`${FOAF}Organization`);
@@ -54,7 +54,7 @@ describe('buildAgentsTurtle (mjs)', () => {
   });
 
   it('emits only prefix declarations for an empty input', async () => {
-    const ttl = await buildAgentsTurtle([]);
+    const ttl = await buildAgentsTurtle([], 'https://glossarist.org/agent');
     expect(ttl).toContain('@prefix foaf:');
     expect(ttl).not.toContain('<https://glossarist.org/agent/');
   });

package/src/__tests__/scripts/bibliography-turtle.test.ts

@@ -15,13 +15,13 @@ function parse(turtle: string): Store {
 
 describe('buildBibliographyTurtle (mjs)', () => {
   it('parses without errors', async () => {
-    const ttl = await buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } });
+    const ttl = await buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } }, 'https://glossarist.org');
     const store = parse(ttl);
     expect(store.size).toBeGreaterThan(0);
   });
 
   it('types each entry as dcterms:BibliographicResource', async () => {
-    const ttl = await buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } });
+    const ttl = await buildBibliographyTurtle('iso-geodetic', { iso704: { reference: 'ISO 704' } }, 'https://glossarist.org');
     const store = parse(ttl);
     const types = store.getObjects('https://glossarist.org/iso-geodetic/bib/iso704', RDF_TYPE, null).map(q => q.value);
     expect(types).toContain(`${DCTERMS}BibliographicResource`);
@@ -30,7 +30,7 @@ describe('buildBibliographyTurtle (mjs)', () => {
   it('emits identifier, bibliographicCitation, and title', async () => {
     const ttl = await buildBibliographyTurtle('iso-geodetic', {
       iso704: { reference: 'ISO 704', title: 'Terminology work — Principles and methods' },
-    });
+    }, 'https://glossarist.org');
     const store = parse(ttl);
     const iri = 'https://glossarist.org/iso-geodetic/bib/iso704';
     expect(store.getObjects(iri, `${DCTERMS}identifier`, null).map(q => q.value)).toContain('iso704');
@@ -41,7 +41,7 @@ describe('buildBibliographyTurtle (mjs)', () => {
   it('emits foaf:page when link is provided', async () => {
     const ttl = await buildBibliographyTurtle('iso-geodetic', {
       ref: { reference: 'X', link: 'https://example.org/x' },
-    });
+    }, 'https://glossarist.org');
     const store = parse(ttl);
     const iri = 'https://glossarist.org/iso-geodetic/bib/ref';
     expect(store.getObjects(iri, `${FOAF}page`, null).map(q => q.value)).toContain('https://example.org/x');
@@ -51,7 +51,7 @@ describe('buildBibliographyTurtle (mjs)', () => {
     const ttl = await buildBibliographyTurtle('iso-geodetic', {
       a: { reference: 'A' },
       b: { reference: 'B' },
-    });
+    }, 'https://glossarist.org');
     const store = parse(ttl);
     expect(store.getObjects('https://glossarist.org/iso-geodetic/bib/a', `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('A');
     expect(store.getObjects('https://glossarist.org/iso-geodetic/bib/b', `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('B');

package/src/__tests__/scripts/build-integration.test.ts

@@ -61,7 +61,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
   it('agents-turtle.mjs produces parseable foaf:Person', () => {
     const out = runInline(`
       import { buildAgentsTurtle } from './scripts/lib/agents-turtle.mjs';
-      console.log(await buildAgentsTurtle([{ name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society' }]));
+      console.log(await buildAgentsTurtle([{ name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society' }], 'https://glossarist.org/agent'));
     `);
     const store = parseTurtle(out);
     const persons = [...store].filter(q =>
@@ -74,7 +74,7 @@ describe('WS F Layer 8 — build pipeline integration', () => {
   it('bibliography-turtle.mjs produces parseable dcterms:BibliographicResource', () => {
     const out = runInline(`
       import { buildBibliographyTurtle } from './scripts/lib/bibliography-turtle.mjs';
-      console.log(await buildBibliographyTurtle('test', { iso704: { reference: 'ISO 704' } }));
+      console.log(await buildBibliographyTurtle('test', { iso704: { reference: 'ISO 704' } }, 'https://glossarist.org'));
     `);
     const store = parseTurtle(out);
     const bibs = [...store].filter(q =>
@@ -122,8 +122,8 @@ describe('WS F Layer 8 — build pipeline integration', () => {
         await buildVocabularyTurtle(),
         await buildDatasetTurtle({ datasetIri: 'https://glossarist.org/test/', registerId: 'test', title: 't', modified: '2026-01-01', languages: ['eng'], distributions: [], topConceptUris: [], sections: [] }),
         await buildActivityTurtle({ runId: 'r', startedAt: '2026-01-01T00:00:00Z', endedAt: '2026-01-01T00:05:00Z', toolId: 'cb', toolVersion: '0', datasetRegisters: [], conceptCount: 0 }),
-        await buildAgentsTurtle([{ name: 'Ada' }]),
-        await buildBibliographyTurtle('test', { x: { reference: 'X' } }),
+        await buildAgentsTurtle([{ name: 'Ada' }], 'https://glossarist.org/agent'),
+        await buildBibliographyTurtle('test', { x: { reference: 'X' } }, 'https://glossarist.org'),
         await buildVersionHistoryTurtle({ registerId: 't', datasetIri: 'https://glossarist.org/t/', versions: [{ version: '1', generatedAt: '2026-01-01' }] }),
       ];
       console.log(parts.join('\\n'));

package/src/__tests__/test-helpers.ts

@@ -38,6 +38,7 @@ export function makeManifest(overrides: Partial<Manifest> = {}): Manifest {
 
 export interface AdapterStubOptions {
   concepts?: ConceptSummary[];
+  manifest?: Manifest | null;
   search?: () => SearchHit[];
   fetchConcept?: () => Promise<any>;
   getAdjacentConcepts?: () => { prev: string | null; next: string | null };
@@ -55,7 +56,7 @@ export interface AdapterStubOptions {
 export function makeAdapterStub(options: AdapterStubOptions = {}): any {
   return {
     index: options.concepts ?? [],
-    manifest: null,
+    manifest: options.manifest ?? makeManifest(),
     registerId: 'test',
     getConceptCount: () => (options.concepts ?? []).length,
     getConcepts: () => options.concepts ?? [],

package/src/adapters/GraphDataSource.ts

@@ -42,7 +42,9 @@ export class GraphDataSource {
   }
 
   private get uriBase(): string {
-    return this.adapter.manifest?.uriBase || 'https://glossarist.org';
+    const uriBase = this.adapter.manifest?.uriBase;
+    if (!uriBase) throw new Error('GraphDataSource: manifest.uriBase is required');
+    return uriBase;
   }
 
   private get urnMap(): ReadonlyMap<string, string> {

package/src/components/RelationSphere.vue

@@ -18,6 +18,7 @@ import { useDsStyle } from '../utils/dataset-style';
 import { getFactory } from '../adapters/factory';
 import { SPHERE_RELATION_CATEGORIES as RELATION_CATEGORIES, sphereCategoryForType as categoryForType, categorizeRelationForSphere as categorizeRelation, colorForTypeInMode as colorForTypeRaw, relationLabel as relationTypeLabel } from '../utils/relation-sphere-styling';
 import { easeInOutCubic, slerp, fibonacciSpherePosition, project, cardEdge, type Vec3 } from '../composables/useSphereProjection';
+import { UriRouter } from '../adapters/UriRouter';
 import { getPreferredTerm } from '../utils/concept-helpers';
 import { renderContent } from '../utils/content-renderer';
 import { useI18n } from '../i18n';
@@ -112,7 +113,8 @@ let navDuration = 2200;  /* mutable — shorter for expand changes than for conc
 async function loadNeighborTerms() {
   const factory = getFactory();
   const lang = sphereLang.value;
-  const uriBase = props.manifest.uriBase || 'https://glossarist.org';
+  const uriBase = props.manifest.uriBase;
+  if (!uriBase) throw new Error('RelationSphere: manifest.uriBase is required');
   const neighborRegisters = new Set<string>();
 
   /* Phase 1: collect which neighbor datasets we need to load */
@@ -226,14 +228,6 @@ function updateNodeTerm(n: SNode) {
 }
 
 /* ── Build internal graph from concept + edges (BFS) ────── */
-function parseNeighborUri(uri: string, fallbackReg: string): { register: string; conceptId: string } | null {
-  const m = uri.match(/(?:glossarist\.org|oimlsmart\.github\.io\/vocab)\/([^/]+)\/concept\/([^/?#]+)/);
-  if (m) return { register: m[1], conceptId: m[2] };
-  /* URN or other shape — use fallback register, last path segment as id */
-  const parts = uri.split('/').filter(Boolean);
-  if (parts.length === 0) return null;
-  return { register: fallbackReg, conceptId: parts[parts.length - 1] };
-}
 
 function hashSeed(s: string): number {
   let h = 0;
@@ -280,12 +274,12 @@ function buildGraph() {
 
   /* First pass: collect depth-1 neighbors (deduped) so we know N for even
      ring placement. */
-  const depth1List: Array<{ uri: string; parsed: { register: string; conceptId: string }; isOutgoing: boolean; edge: GraphEdge }> = [];
+  const depth1List: Array<{ uri: string; parsed: { registerId: string; conceptId: string }; isOutgoing: boolean; edge: GraphEdge }> = [];
   for (const edge of props.edges) {
     const isOutgoing = edge.source === focusUri || edge.source === focusId;
     const otherUri = isOutgoing ? edge.target : edge.source;
     if (!otherUri || visited.has(otherUri)) continue;
-    const parsed = parseNeighborUri(otherUri, edge.register || props.registerId);
+    const parsed = UriRouter.parseUri(otherUri);
     if (!parsed || parsed.conceptId === focusId) continue;
     visited.set(otherUri, 1);
     depth1List.push({ uri: otherUri, parsed, isOutgoing, edge });
@@ -298,8 +292,8 @@ function buildGraph() {
     nodeMap.set(parsed.conceptId, {
       id: parsed.conceptId,
       term: edge.label || parsed.conceptId,
-      ref: parsed.register,
-      register: parsed.register,
+      ref: parsed.registerId,
+      register: parsed.registerId,
       conceptId: parsed.conceptId,
       depth: 1,
       x: pos.x, y: pos.y, z: pos.z,
@@ -331,13 +325,13 @@ function buildGraph() {
     const inEdges = store.graph.getIncomingEdges(uri);
     /* Collect this node's children first so we can place them as an even
        sub-ring around their parent. */
-    const children: Array<{ uri: string; parsed: { register: string; conceptId: string }; isOutgoing: boolean; edge: GraphEdge }> = [];
+    const children: Array<{ uri: string; parsed: { registerId: string; conceptId: string }; isOutgoing: boolean; edge: GraphEdge }> = [];
     for (const edge of [...outEdges, ...inEdges]) {
       if (nodeMap.size + children.length >= MAX_NODES) break;
       const isOutgoing = edge.source === uri;
       const otherUri = isOutgoing ? edge.target : edge.source;
       if (!otherUri || visited.has(otherUri)) continue;
-      const parsed = parseNeighborUri(otherUri, edge.register || props.registerId);
+      const parsed = UriRouter.parseUri(otherUri);
       if (!parsed || parsed.conceptId === focusId || nodeMap.has(parsed.conceptId)) continue;
       visited.set(otherUri, depth + 1);
       children.push({ uri: otherUri, parsed, isOutgoing, edge });
@@ -347,8 +341,8 @@ function buildGraph() {
       nodeMap.set(parsed.conceptId, {
         id: parsed.conceptId,
         term: parsed.conceptId,
-        ref: parsed.register,
-        register: parsed.register,
+        ref: parsed.registerId,
+        register: parsed.registerId,
         conceptId: parsed.conceptId,
         depth: depth + 1,
         x: pos.x, y: pos.y, z: pos.z,

package/src/stores/vocabulary.ts

@@ -207,7 +207,8 @@ export const useVocabularyStore = defineStore('vocabulary', () => {
       // We do NOT call adapter.extractEdges(concept) here because that would duplicate
       // edges already present in edges.json, causing double-rendering of relations.
       const domainEdges = adapter.extractDomainEdges(concept);
-      const uriBase = adapter.manifest?.uriBase || 'https://glossarist.org';
+      const uriBase = adapter.manifest?.uriBase;
+      if (!uriBase) throw new Error('vocabulary store: manifest.uriBase is required — set uriBase in site-config.yml');
       const uri = conceptUri(concept, registerId, uriBase);
 
       const designations: Record<string, string> = {};