@glossarist/concept-browser 0.7.117 → 0.7.119

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glossarist/concept-browser",
-  "version": "0.7.117",
+  "version": "0.7.119",
   "description": "Vue SPA for browsing Glossarist terminology datasets with cross-reference resolution, graph visualization, and multi-language support",
   "type": "module",
   "bin": {
@@ -42,7 +42,7 @@
     "astro": "^7.0.7",
     "d3": "^7.9.0",
     "favicons": "^7.2.0",
-    "glossarist": "^0.4.52",
+    "glossarist": "^0.4.54",
     "js-yaml": "^4.1.0",
     "jszip": "^3.10.1",
     "n3": "^1.26.0",

package/scripts/build-edges.js

@@ -157,6 +157,16 @@ function extractRelated(concept, registerId, uriBase, urnMap) {
   const edges = [];
   const sourceUri = concept["@id"];
   for (const r of concept["gl:related"] || []) {
+    if (r["gl:target"]) {
+      edges.push({
+        source: sourceUri,
+        target: r["gl:target"],
+        type: r["gl:relationshipType"] || "references",
+        label: r["gl:term"] || void 0,
+        register: r["gl:target"].match(/\/([^/]+)\/concept\//)?.[1] || registerId
+      });
+      continue;
+    }
     const ref = r["gl:ref"];
     if (!ref) continue;
     const source = ref["gl:source"] || ref["source"];
@@ -382,6 +392,9 @@ function main() {
         const base = alias.endsWith("*") ? alias.slice(0, -1) : alias;
         if (base) urnMap.set(base, ds);
       }
+      if (manifest.ref) {
+        urnMap.set(manifest.ref, ds);
+      }
     } catch {
     }
   }

package/scripts/build-edges.ts

@@ -173,6 +173,19 @@ function extractRelated(concept, registerId, uriBase, urnMap) {
   const edges = [];
   const sourceUri = concept['@id'];
   for (const r of concept['gl:related'] || []) {
+    // Prefer gl:target — already resolved at generate-data build time
+    // via refPrefixMap (maps dataset ref labels to dataset IDs).
+    if (r['gl:target']) {
+      edges.push({
+        source: sourceUri,
+        target: r['gl:target'],
+        type: r['gl:relationshipType'] || 'references',
+        label: r['gl:term'] || undefined,
+        register: r['gl:target'].match(/\/([^/]+)\/concept\//)?.[1] || registerId,
+      });
+      continue;
+    }
+    // Fallback: resolve from gl:ref using urnMap
     const ref = r['gl:ref'];
     if (!ref) continue;
     const source = ref['gl:source'] || ref['source'];
@@ -458,6 +471,12 @@ for (const ds of datasets) {
       const base = alias.endsWith('*') ? alias.slice(0, -1) : alias;
       if (base) urnMap.set(base, ds);
     }
+    // Map the dataset's ref label (e.g. "CIE S 017:2020") to its dataset ID.
+    // This enables cross-dataset resolution for gl:ref entries that use
+    // source labels instead of URIs.
+    if (manifest.ref) {
+      urnMap.set(manifest.ref, ds);
+    }
   } catch {}
 }
 console.log(`URI resolution map: ${[...urnMap.entries()].map(([k,v]) => `${k}→${v}`).join(', ')}\n`);

package/scripts/generate-data.js

@@ -420,7 +420,7 @@ async function buildActivityTurtle(input) {
 }
 
 // scripts/lib/vocab-turtle.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
 import { join, dirname as dirname2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
@@ -430,9 +430,21 @@ import {
   PREFIXES as PREFIXES2
 } from "glossarist/rdf";
 var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
-var VOCAB_PATH = join(__dirname2, "..", "..", "data", "glossarist-vocab.json");
-function loadVocab(path4 = VOCAB_PATH) {
-  return JSON.parse(readFileSync2(path4, "utf8"));
+function findVocabPath() {
+  const candidates = [
+    join(__dirname2, "..", "..", "data", "glossarist-vocab.json"),
+    join(__dirname2, "..", "data", "glossarist-vocab.json")
+  ];
+  for (const p of candidates) {
+    if (existsSync2(p)) return p;
+  }
+  throw new Error(
+    `glossarist-vocab.json not found. Tried:
+${candidates.map((p) => "  " + p).join("\n")}`
+  );
+}
+function loadVocab() {
+  return JSON.parse(readFileSync2(findVocabPath(), "utf8"));
 }
 function writerPrefixes3() {
   const out = {};
@@ -1090,6 +1102,9 @@ function buildPatternIndex(datasets, registerCache2) {
 function buildRefMaps(config2, registerCache2) {
   const refPrefixMap = {};
   const patternIndex = buildPatternIndex(config2.datasets, registerCache2);
+  for (const ds of config2.datasets) {
+    if (ds.ref) refPrefixMap[ds.ref] = ds.id;
+  }
   for (const route of config2.routing || []) {
     if (route.uri && route.uri.includes("iec") && route.uri.includes("60050")) {
       const mapped = route.targetDataset;
@@ -1316,6 +1331,13 @@ function yamlToJsonLd(conceptYaml, register, refMaps2) {
         if (r.ref.id) ref["gl:id"] = r.ref.id;
         if (r.ref.text) ref["gl:text"] = r.ref.text;
         rel["gl:ref"] = ref;
+        if (r.ref.source && r.ref.id && refMaps2?.refPrefixMap?.[r.ref.source]) {
+          const datasetId = refMaps2.refPrefixMap[r.ref.source];
+          rel["gl:target"] = buildConceptUri(refMaps2.uriBase, datasetId, r.ref.id);
+        }
+      }
+      if (r.target) {
+        rel["gl:target"] = r.target;
       }
       return rel;
     });

package/scripts/generate-data.ts

@@ -221,6 +221,14 @@ function buildRefMaps(config, registerCache) {
   const refPrefixMap = {};
   const patternIndex = buildPatternIndex(config.datasets, registerCache);
 
+  // Auto-map each dataset's `ref` field to its dataset ID.
+  // This enables cross-dataset link resolution: a concept in cie-2020
+  // with ref: { source: "CIE S 017:2011", id: "17-245" } resolves to
+  // cie-2011/concept/17-245 because cie-2011 has ref: "CIE S 017:2011".
+  for (const ds of config.datasets) {
+    if (ds.ref) refPrefixMap[ds.ref] = ds.id;
+  }
+
   for (const route of config.routing || []) {
     if (route.uri && route.uri.includes('iec') && route.uri.includes('60050')) {
       const mapped = route.targetDataset;
@@ -508,6 +516,18 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
         if (r.ref.id) ref['gl:id'] = r.ref.id;
         if (r.ref.text) ref['gl:text'] = r.ref.text;
         rel['gl:ref'] = ref;
+
+        // Resolve cross-dataset refs to gl:target URIs.
+        // refPrefixMap maps source labels (e.g. "CIE S 017:2011") to
+        // dataset IDs (e.g. "cie-2011"). When the source matches a
+        // co-deployed dataset, we can build a navigable concept URI.
+        if (r.ref.source && r.ref.id && refMaps?.refPrefixMap?.[r.ref.source]) {
+          const datasetId = refMaps.refPrefixMap[r.ref.source];
+          rel['gl:target'] = buildConceptUri(refMaps.uriBase, datasetId, r.ref.id);
+        }
+      }
+      if (r.target) {
+        rel['gl:target'] = r.target;
       }
       return rel;
     });

package/scripts/lib/vocab-turtle.ts

@@ -7,7 +7,7 @@
 // to absolute IRIs, then re-rendered via glossarist-js's n3 writer with
 // the canonical prefix map ).
 
-import { readFileSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
@@ -18,10 +18,25 @@ import {
 } from 'glossarist/rdf';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const VOCAB_PATH = join(__dirname, '..', '..', 'data', 'glossarist-vocab.json');
 
-function loadVocab(path = VOCAB_PATH) {
-  return JSON.parse(readFileSync(path, 'utf8'));
+// When running from source (tsx), this file is at scripts/lib/ and
+// the data dir is two levels up. When bundled by esbuild into
+// scripts/*.js, __dirname is scripts/ and the data dir is one level up.
+function findVocabPath(): string {
+  const candidates = [
+    join(__dirname, '..', '..', 'data', 'glossarist-vocab.json'),
+    join(__dirname, '..', 'data', 'glossarist-vocab.json'),
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  throw new Error(
+    `glossarist-vocab.json not found. Tried:\n${candidates.map(p => '  ' + p).join('\n')}`,
+  );
+}
+
+function loadVocab() {
+  return JSON.parse(readFileSync(findVocabPath(), 'utf8'));
 }
 
 // n3's writer prefixes must omit the trailing # or / — those go in

package/src/__tests__/adapters/cross-dataset-related.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { conceptFromJson } from '../../adapters/model-bridge';
+
+function makeJsonLdWithRelated(target: string | null) {
+  const related = target
+    ? {
+        'gl:relationshipType': 'superseded_by',
+        'gl:target': target,
+        'gl:ref': { 'gl:source': 'CIE S 017:2020', 'gl:id': '17-21-097' },
+      }
+    : {
+        'gl:relationshipType': 'superseded_by',
+        'gl:ref': { 'gl:source': 'CIE S 017:2020', 'gl:id': '17-21-097' },
+      };
+  return {
+    '@type': 'skos:Concept',
+    '@id': 'https://example.com/cie-2011/concept/17-50',
+    'gl:identifier': '17-50',
+    'gl:localizedConcept': {
+      eng: {
+        'gl:languageCode': 'eng',
+        'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'test term', 'gl:normativeStatus': 'preferred' }],
+        'gl:definition': [{ 'gl:content': 'test definition' }],
+      },
+    },
+    'gl:related': [related],
+  };
+}
+
+describe('cross-dataset related concept resolution — gl:target flows through model-bridge natively', () => {
+  it('concept.relatedConcepts entries with gl:target have native target field', () => {
+    const json = makeJsonLdWithRelated('https://example.com/cie-2020/concept/17-21-097');
+    const concept = conceptFromJson(json as any);
+    expect(concept.relatedConcepts).toHaveLength(1);
+    expect(concept.relatedConcepts[0].type).toBe('superseded_by');
+    expect(concept.relatedConcepts[0].target).toBe('https://example.com/cie-2020/concept/17-21-097');
+  });
+
+  it('concept.relatedConcepts entries without gl:target have null target', () => {
+    const json = makeJsonLdWithRelated(null);
+    const concept = conceptFromJson(json as any);
+    expect(concept.relatedConcepts).toHaveLength(1);
+    expect(concept.relatedConcepts[0].target).toBeNull();
+  });
+});

package/src/__tests__/consumer-e2e-simulation.test.ts

@@ -0,0 +1,98 @@
+/**
+ * End-to-end consumer simulation test.
+ *
+ * Simulates what a real consumer experiences: creates a temp "consumer
+ * project" with the compiled package in node_modules, then runs scripts
+ * with plain node. Catches packaging bugs that dev-mode tests miss.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import {
+  mkdirSync, writeFileSync, cpSync, rmSync, existsSync, readFileSync, readdirSync,
+} from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..', '..');
+const SCRIPTS_DIR = join(ROOT, 'scripts');
+const CONSUMER_DIR = join(ROOT, '.tmp-consumer-test');
+
+describe('end-to-end consumer simulation — compiled package works under plain node', () => {
+  beforeAll(() => {
+    const build = spawnSync('node', [join(ROOT, 'scripts', 'build-scripts.mjs')], {
+      encoding: 'utf8', cwd: ROOT,
+    });
+    expect(build.status).toBe(0);
+
+    rmSync(CONSUMER_DIR, { recursive: true, force: true });
+    const pkgDest = join(CONSUMER_DIR, 'node_modules', '@glossarist', 'concept-browser');
+    mkdirSync(pkgDest, { recursive: true });
+    cpSync(join(ROOT, 'scripts'), join(pkgDest, 'scripts'), { recursive: true });
+    cpSync(join(ROOT, 'data'), join(pkgDest, 'data'), { recursive: true });
+    cpSync(join(ROOT, 'cli'), join(pkgDest, 'cli'), { recursive: true });
+    writeFileSync(join(pkgDest, 'package.json'), JSON.stringify({
+      name: '@glossarist/concept-browser', version: '0.0.0-test', type: 'module',
+      bin: { 'concept-browser': './cli/index.mjs' },
+    }));
+  }, 60000);
+
+  afterAll(() => {
+    rmSync(CONSUMER_DIR, { recursive: true, force: true });
+  });
+
+  it('compiled scripts can find package data files from node_modules location', () => {
+    const scriptDir = join(CONSUMER_DIR, 'node_modules', '@glossarist', 'concept-browser', 'scripts');
+    const pathFromBundled = join(scriptDir, '..', 'data', 'glossarist-vocab.json');
+    expect(existsSync(pathFromBundled)).toBe(true);
+  });
+
+  it('compiled scripts list matches source scripts (no missing outputs)', () => {
+    const sourceTs = readdirSync(SCRIPTS_DIR)
+      .filter(f => f.endsWith('.ts') && !f.includes('__tests__') && f !== 'smoke.ts')
+      .map(f => f.replace(/\.ts$/, ''));
+    const compiledJs = readdirSync(SCRIPTS_DIR)
+      .filter(f => f.endsWith('.js'))
+      .map(f => f.replace(/\.js$/, ''));
+    for (const name of sourceTs) {
+      expect(compiledJs).toContain(name);
+    }
+  });
+
+  it('validate-yaml.js validates against the shipped schema from node_modules', () => {
+    const consumerPkg = join(CONSUMER_DIR, 'node_modules', '@glossarist', 'concept-browser');
+    const scriptPath = join(consumerPkg, 'scripts', 'validate-yaml.js');
+    const schemaPath = join(consumerPkg, 'data', 'concept-model', 'shapes', 'glossarist.concept.yaml.schema.json');
+    const code = [
+      'import { validateYaml } from ' + JSON.stringify(scriptPath) + ';',
+      'import { readFileSync } from "fs";',
+      'const schema = JSON.parse(readFileSync(' + JSON.stringify(schemaPath) + ', "utf8"));',
+      'const r = validateYaml("termid: test", schema);',
+      'console.log("valid=" + r.valid);',
+    ].join('\n');
+    const result = spawnSync('node', ['--input-type=module', '-e', code], {
+      encoding: 'utf8', cwd: ROOT,
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('valid=true');
+  });
+
+  it('no compiled script references a devDependency-only package', () => {
+    const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'));
+    const deps = new Set(Object.keys(pkg.dependencies || {}));
+    const devDeps = new Set(Object.keys(pkg.devDependencies || {}));
+    const violations: string[] = [];
+    for (const file of readdirSync(SCRIPTS_DIR).filter(f => f.endsWith('.js'))) {
+      const src = readFileSync(join(SCRIPTS_DIR, file), 'utf8');
+      const importRe = new RegExp('(?:from\\s+|import\\s*\\(\\s*)["\']([^"\'./@][^"\']*)["\']', 'g');
+      let m;
+      while ((m = importRe.exec(src)) !== null) {
+        const name = m[1].startsWith('@') ? m[1].split('/').slice(0, 2).join('/') : m[1].split('/')[0];
+        if (name.startsWith('node:') || name === 'node') continue;
+        if (devDeps.has(name) && !deps.has(name)) violations.push(file + ' -> ' + name);
+      }
+    }
+    expect(violations).toEqual([]);
+  });
+});

package/src/__tests__/published-package-contract.test.ts

@@ -97,4 +97,14 @@ describe('published-package contract — compiled .js scripts load under plain n
       }
     }
   });
+
+  it('compiled scripts can find package data files (glossarist-vocab.json path regression)', () => {
+    // When esbuild bundles scripts/lib/vocab-turtle.ts into scripts/generate-data.js,
+    // __dirname changes from scripts/lib/ to scripts/. The path to data/ must
+    // resolve correctly in both modes. This test verifies the fallback logic.
+    const dataDir = join(ROOT, 'data');
+    expect(existsSync(join(dataDir, 'glossarist-vocab.json'))).toBe(true);
+    expect(existsSync(join(dataDir, 'colors.json'))).toBe(true);
+    expect(existsSync(join(dataDir, 'concept-model', 'shapes', 'glossarist.shacl.ttl'))).toBe(true);
+  });
 });

package/src/adapters/model-bridge.ts

@@ -367,6 +367,13 @@ function mapRelatedFromJsonLd(r: JsonLdRelated): Record<string, unknown> {
     result.type = r[GL.RELATIONSHIP_TYPE];
   }
 
+  // gl:target is the resolved concept URI for cross-dataset relations
+  // (e.g., superseded_by → cie-2020 concept). Without this, the UI
+  // renders related concepts as plain text with no clickable link.
+  if (r[GL.TARGET]) {
+    result.target = r[GL.TARGET];
+  }
+
   if (r[GL.REF]) {
     const ref = mapRefFromJsonLd(r[GL.REF]);
     if (ref) result.ref = ref;