@glossarist/concept-browser 0.7.138 → 0.7.139

package/package.json

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

@@ -29,6 +29,26 @@ function extractSourceRefs(concept, registerId) {
 import { readFileSync, writeFileSync, readdirSync, existsSync, realpathSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+
+// src/utils/slugify.ts
+var KEEP = /[^\p{L}\p{N}\p{M}_\s-]/gu;
+var HAS_WORD = /[\p{L}\p{N}]/u;
+function shortHash(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function slugify(text) {
+  if (text === "") return "";
+  const folded = text.normalize("NFKC").toLowerCase();
+  const slug = folded.replace(KEEP, "").replace(/[\s/]+/g, "-");
+  return HAS_WORD.test(slug) ? slug : `x-${shortHash(folded.trim())}`;
+}
+
+// scripts/build-edges.ts
 var VALID_COMPLETENESS = /* @__PURE__ */ new Set(["complete", "partial"]);
 function validateCompleteness(value) {
   if (value == null) return "complete";
@@ -82,9 +102,6 @@ function normalizeLocalizedString(content) {
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var ROOT = process.cwd();
 var DATA_DIR = join(ROOT, "public", "data");
-function slugify(text) {
-  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s/]+/g, "-");
-}
 function extractReferences(concept, registerId) {
   const edges = [];
   const sourceUri = concept["@id"];

package/scripts/build-edges.ts

@@ -82,17 +82,12 @@ import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import yaml from 'js-yaml';
 import { Register } from 'glossarist';
+import { slugify } from '../src/utils/slugify';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = process.cwd();
 const DATA_DIR = join(ROOT, 'public', 'data');
 
-// --- Normalization ---
-
-function slugify(text) {
-  return text.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
-}
-
 // --- Extractors (open/closed: add new extractors to EXTRACTORS array) ---
 
 function extractReferences(concept: Record<string, any>, registerId: string) {

package/src/__fixtures__/isotc211-domain-slugs.json

@@ -0,0 +1,201 @@
+{
+ "DGGS": "dggs",
+ "Euclidean geometry": "euclidean-geometry",
+ "GML": "gml",
+ "GeoDRM": "geodrm",
+ "Geometrie": "geometrie",
+ "Georeferenzierung": "georeferenzierung",
+ "ICT": "ict",
+ "Koordinate": "koordinate",
+ "LIDAR": "lidar",
+ "OAIS": "oais",
+ "OWL": "owl",
+ "RDF": "rdf",
+ "Radar": "radar",
+ "SAR": "sar",
+ "SONAR": "sonar",
+ "UML": "uml",
+ "Verweisung": "verweisung",
+ "XML": "xml",
+ "XML Schema": "xml-schema",
+ "XMLSchema": "xmlschema",
+ "addressing": "addressing",
+ "allgemein": "allgemein",
+ "as a modifier": "as-a-modifier",
+ "cobertura": "cobertura",
+ "coordenadas": "coordenadas",
+ "coordinate": "coordinate",
+ "coordinate geometry": "coordinate-geometry",
+ "couverture": "couverture",
+ "coverage": "coverage",
+ "de un sistema": "de-un-sistema",
+ "differential geometry": "differential-geometry",
+ "differential geometry, calculus": "differential-geometry-calculus",
+ "differential geometry, geodesy": "differential-geometry-geodesy",
+ "earth observation": "earth-observation",
+ "einparametrige Menge von Geometrien": "einparametrige-menge-von-geometrien",
+ "general": "general",
+ "general vocabulary": "general-vocabulary",
+ "geodesia": "geodesia",
+ "geodesy": "geodesy",
+ "geometri": "geometri",
+ "geometria": "geometria",
+ "geometry": "geometry",
+ "geometry, metric spaces": "geometry-metric-spaces",
+ "geometry, navigation": "geometry-navigation",
+ "geometry, topology": "geometry-topology",
+ "geoposicionamiento": "geoposicionamiento",
+ "geopositioning": "geopositioning",
+ "iso-10241-1": "iso-10241-1",
+ "iso-10303-227": "iso-10303-227",
+ "iso-1087-1": "iso-1087-1",
+ "iso-12005": "iso-12005",
+ "iso-12620": "iso-12620",
+ "iso-12718": "iso-12718",
+ "iso-14055-1": "iso-14055-1",
+ "iso-14721": "iso-14721",
+ "iso-17123-1": "iso-17123-1",
+ "iso-19101": "iso-19101",
+ "iso-19101-1": "iso-19101-1",
+ "iso-19101-2": "iso-19101-2",
+ "iso-19103": "iso-19103",
+ "iso-19104": "iso-19104",
+ "iso-19105": "iso-19105",
+ "iso-19106": "iso-19106",
+ "iso-19107": "iso-19107",
+ "iso-19108": "iso-19108",
+ "iso-19109": "iso-19109",
+ "iso-19110": "iso-19110",
+ "iso-19111": "iso-19111",
+ "iso-19111-2": "iso-19111-2",
+ "iso-19112": "iso-19112",
+ "iso-19113": "iso-19113",
+ "iso-19114": "iso-19114",
+ "iso-19115": "iso-19115",
+ "iso-19115-1": "iso-19115-1",
+ "iso-19115-2": "iso-19115-2",
+ "iso-19115-3": "iso-19115-3",
+ "iso-19116": "iso-19116",
+ "iso-19117": "iso-19117",
+ "iso-19118": "iso-19118",
+ "iso-19119": "iso-19119",
+ "iso-19123": "iso-19123",
+ "iso-19123-1": "iso-19123-1",
+ "iso-19123-2": "iso-19123-2",
+ "iso-19123-3": "iso-19123-3",
+ "iso-19125-1": "iso-19125-1",
+ "iso-19125-2": "iso-19125-2",
+ "iso-19126": "iso-19126",
+ "iso-19128": "iso-19128",
+ "iso-19130-1": "iso-19130-1",
+ "iso-19131": "iso-19131",
+ "iso-19132": "iso-19132",
+ "iso-19133": "iso-19133",
+ "iso-19134": "iso-19134",
+ "iso-19135": "iso-19135",
+ "iso-19135-1": "iso-19135-1",
+ "iso-19136": "iso-19136",
+ "iso-19136-1": "iso-19136-1",
+ "iso-19136-2": "iso-19136-2",
+ "iso-19141": "iso-19141",
+ "iso-19142": "iso-19142",
+ "iso-19143": "iso-19143",
+ "iso-19144-1": "iso-19144-1",
+ "iso-19144-2": "iso-19144-2",
+ "iso-19145": "iso-19145",
+ "iso-19146": "iso-19146",
+ "iso-19147": "iso-19147",
+ "iso-19148": "iso-19148",
+ "iso-19150-2": "iso-19150-2",
+ "iso-19150-4": "iso-19150-4",
+ "iso-19152": "iso-19152",
+ "iso-19153": "iso-19153",
+ "iso-19154": "iso-19154",
+ "iso-19155": "iso-19155",
+ "iso-19155-2": "iso-19155-2",
+ "iso-19156": "iso-19156",
+ "iso-19157": "iso-19157",
+ "iso-19157-1": "iso-19157-1",
+ "iso-19160-1": "iso-19160-1",
+ "iso-19160-2": "iso-19160-2",
+ "iso-19160-4": "iso-19160-4",
+ "iso-19162": "iso-19162",
+ "iso-19165-2": "iso-19165-2",
+ "iso-19168-1": "iso-19168-1",
+ "iso-19168-2": "iso-19168-2",
+ "iso-19170-1": "iso-19170-1",
+ "iso-21000-5": "iso-21000-5",
+ "iso-22028-1": "iso-22028-1",
+ "iso-22300": "iso-22300",
+ "iso-24619": "iso-24619",
+ "iso-2859-1": "iso-2859-1",
+ "iso-2859-5": "iso-2859-5",
+ "iso-31-2": "iso-31-2",
+ "iso-3534-1": "iso-3534-1",
+ "iso-3534-2": "iso-3534-2",
+ "iso-5127": "iso-5127",
+ "iso-6709": "iso-6709",
+ "iso-8000-2": "iso-8000-2",
+ "iso-80000-7": "iso-80000-7",
+ "iso-860": "iso-860",
+ "iso-8601": "iso-8601",
+ "iso-8601-1": "iso-8601-1",
+ "iso-9000": "iso-9000",
+ "iso-9241-5": "iso-9241-5",
+ "iso-dis-19123-1": "iso-dis-19123-1",
+ "iso-iec-10746-2": "iso-iec-10746-2",
+ "iso-iec-10746-3": "iso-iec-10746-3",
+ "iso-iec-18477-4": "iso-iec-18477-4",
+ "iso-iec-19501": "iso-iec-19501",
+ "iso-iec-2382": "iso-iec-2382",
+ "iso-iec-2382-1": "iso-iec-2382-1",
+ "iso-iec-2382-15": "iso-iec-2382-15",
+ "iso-iec-25001": "iso-iec-25001",
+ "iso-iec-25012": "iso-iec-25012",
+ "iso-iec-9075-2": "iso-iec-9075-2",
+ "iso-iec-guide-2": "iso-iec-guide-2",
+ "iso-iec-guide-98-3": "iso-iec-guide-98-3",
+ "iso-iec-guide-99": "iso-iec-guide-99",
+ "iso-iec-ieee-24765": "iso-iec-ieee-24765",
+ "iso-iec-ieee-9945": "iso-iec-ieee-9945",
+ "iso-tr-19120": "iso-tr-19120",
+ "iso-ts-19104": "iso-ts-19104",
+ "iso-ts-19124-1": "iso-ts-19124-1",
+ "iso-ts-19129": "iso-ts-19129",
+ "iso-ts-19130": "iso-ts-19130",
+ "iso-ts-19130-2": "iso-ts-19130-2",
+ "iso-ts-19138": "iso-ts-19138",
+ "iso-ts-19158": "iso-ts-19158",
+ "iso-ts-19159-1": "iso-ts-19159-1",
+ "iso-ts-19159-2": "iso-ts-19159-2",
+ "iso-ts-19159-3": "iso-ts-19159-3",
+ "iso-ts-19159-4": "iso-ts-19159-4",
+ "iso-ts-19163-1": "iso-ts-19163-1",
+ "iso-ts-27790": "iso-ts-27790",
+ "matematicas": "matematicas",
+ "mathematics": "mathematics",
+ "mathematics, computer science": "mathematics-computer-science",
+ "mathematics, programming": "mathematics-programming",
+ "metric": "metric",
+ "metric, topology, geometry": "metric-topology-geometry",
+ "moving features": "moving-features",
+ "one parameter set of geometries": "one-parameter-set-of-geometries",
+ "ontology": "ontology",
+ "paikkatieto": "paikkatieto",
+ "paikkatietojakauma": "paikkatietojakauma",
+ "postal": "postal",
+ "postal address": "postal-address",
+ "programming": "programming",
+ "reference": "reference",
+ "referencia": "referencia",
+ "register": "register",
+ "registro": "registro",
+ "temporal": "temporal",
+ "topology": "topology",
+ "topology, geometry": "topology-geometry",
+ "topology, graph theory": "topology-graph-theory",
+ "topology, metric spaces": "topology-metric-spaces",
+ "user": "user",
+ "vector geometry": "vector-geometry",
+ "vocabulario general": "vocabulario-general"
+}

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

@@ -548,7 +548,7 @@ describe('DatasetAdapter', () => {
       expect(edges.length).toBe(2);
       expect(edges.every(e => e.type === 'domain')).toBe(true);
       expect(edges.find(e => e.lang === 'eng')?.target).toContain('/domain/geometry');
-      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/domain/gomtrie');
+      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/domain/géométrie');
       expect(edges.find(e => e.lang === 'eng')?.label).toBe('geometry');
       expect(edges.find(e => e.lang === 'fra')?.label).toBe('géométrie');
     });

package/src/__tests__/slugify.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { slugify } from '../utils/slugify';
+import publishedSlugs from '../__fixtures__/isotc211-domain-slugs.json';
 
 describe('slugify', () => {
   it('lowercases text', () => {
@@ -11,7 +12,7 @@ describe('slugify', () => {
   });
 
   it('strips non-word characters', () => {
-    expect(slugify('géométrie (2D)')).toBe('gomtrie-2d');
+    expect(slugify('géométrie (2D)')).toBe('géométrie-2d');
   });
 
   it('collapses multiple spaces into single hyphen', () => {
@@ -25,4 +26,76 @@ describe('slugify', () => {
   it('preserves hyphens in input', () => {
     expect(slugify('iso-19107')).toBe('iso-19107');
   });
+
+  describe('unicode labels', () => {
+    it('keeps accented letters', () => {
+      expect(slugify('dirección postal')).toBe('dirección-postal');
+    });
+
+    it('keeps non-Latin scripts', () => {
+      expect(slugify('геопозиционирование')).toBe('геопозиционирование');
+      expect(slugify('地理定位')).toBe('地理定位');
+      expect(slugify('지리 위치')).toBe('지리-위치');
+    });
+
+    it('keeps Arabic combining marks', () => {
+      expect(slugify('نظام الإحداثيات')).toBe('نظام-الإحداثيات');
+    });
+
+    it('is NFC-stable: composed and decomposed input give one slug', () => {
+      expect(slugify('é')).toBe(slugify('é'));
+    });
+
+    it('gives distinct labels distinct slugs', () => {
+      const labels = ['UML', 'dirección postal', 'direccion postal', 'геопозиционирование',
+        '地理定位', '지리 위치', 'تحديد المواقع'];
+      expect(new Set(labels.map(slugify)).size).toBe(labels.length);
+    });
+
+    it('is idempotent', () => {
+      for (const l of ['dirección postal', 'геопозиционирование', '()', 'a b']) {
+        expect(slugify(slugify(l))).toBe(slugify(l));
+      }
+    });
+  });
+
+  describe('labels without letters or digits', () => {
+    it('never returns an empty or separator-only slug', () => {
+      for (const l of ['()', '---', ' ', '!!', '/', '- -']) {
+        expect(slugify(l)).toMatch(/^x-[0-9a-f]{8}$/);
+      }
+    });
+
+    it('distinguishes different such labels', () => {
+      expect(slugify('()')).not.toBe(slugify('[]'));
+      expect(slugify('()')).toBe(slugify('()'));
+    });
+
+    it('still maps empty input to empty (callers guard on truthy)', () => {
+      expect(slugify('')).toBe('');
+    });
+  });
+
+  describe('existing ASCII URLs do not move', () => {
+    // Verbatim copy of the pre-unicode implementation.
+    const legacy = (t: string) => t.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
+
+    it('matches every domain slug published in the isotc211 dataset', () => {
+      const entries = Object.entries(publishedSlugs as Record<string, string>);
+      expect(entries.length).toBeGreaterThan(150);
+      for (const [label, slug] of entries) expect(slugify(label)).toBe(slug);
+    });
+
+    it('is byte-identical to the legacy output for ASCII input with a letter or digit', () => {
+      let seed = 12345;
+      const rnd = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff;
+      for (let i = 0; i < 20000; i++) {
+        const len = 1 + Math.floor(rnd() * 12);
+        let t = '';
+        for (let j = 0; j < len; j++) t += String.fromCharCode(9 + Math.floor(rnd() * 118));
+        if (!/[A-Za-z0-9]/.test(t)) continue;
+        expect(slugify(t)).toBe(legacy(t));
+      }
+    });
+  });
 });

package/src/utils/slugify.ts

@@ -1,3 +1,27 @@
+// Slug for a domain label. Keeps letters and digits of every script so that
+// non-Latin and accented labels stay distinct and readable. Pure-ASCII input
+// that contains a letter or digit yields exactly what the earlier ASCII-only
+// implementation did, so already-published URLs do not move.
+
+const KEEP = /[^\p{L}\p{N}\p{M}_\s-]/gu;
+const HAS_WORD = /[\p{L}\p{N}]/u;
+
+// FNV-1a, 32 bit, over UTF-16 code units. Sync and dependency-free so it runs
+// in the browser and in the Node build scripts alike.
+function shortHash(text: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, '0');
+}
+
 export function slugify(text: string): string {
-  return text.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
+  if (text === '') return '';
+  const folded = text.normalize('NFKC').toLowerCase();
+  const slug = folded.replace(KEEP, '').replace(/[\s/]+/g, '-');
+  // No letter or digit left (e.g. "()", "---"): a hash keeps such labels
+  // from collapsing into one empty node.
+  return HAS_WORD.test(slug) ? slug : `x-${shortHash(folded.trim())}`;
 }