@glossarist/concept-browser 0.7.76 → 0.7.78

package/astro.config.mjs

@@ -20,6 +20,7 @@ export default defineConfig({
   base,
   output: 'static',
   publicDir: resolve(process.cwd(), 'public'),
+  outDir: resolve(process.cwd(), 'dist'),
   integrations: [
     vue({ appEntrypoint: '/src/islands/app-entry' }),
     sitemap(),

package/package.json

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

package/scripts/bridge-to-astro.mjs

@@ -1,3 +1,8 @@
+function buildConceptUri(uriBase, registerId, conceptId) {
+  return `${uriBase}/${registerId}/concept/${conceptId}`;
+}
+
+
 /**
  * Data bridge: converts public/data/*.json into Astro content collections.
  *
@@ -77,7 +82,7 @@ for (const reg of registry) {
       const conceptEntry = {
         registerId: id,
         conceptId: concept.id,
-        uri: `${entry.uriBase || ''}/${id}/concept/${concept.id}`,
+        uri: buildConceptUri(entry.uriBase || '', id, concept.id),
         status: concept.status || 'valid',
         designations: concept.designations || {},
         eng: concept.eng || concept.designations?.eng || '',

package/scripts/build-edges.js

@@ -1,3 +1,27 @@
+function buildConceptUri(uriBase, registerId, conceptId) {
+  return `${uriBase}/${registerId}/concept/${conceptId}`;
+}
+
+const VALID_MARKERS = new Set(['double', 'dashed']);
+
+function validateHyperedgeMarkers(markers) {
+  const out = [];
+  for (const m of markers) {
+    if (!VALID_MARKERS.has(m)) {
+      throw new Error(`Invalid partitive hyperedge marker: "${m}". Allowed: double, dashed`);
+    }
+    out.push(m);
+  }
+  return out;
+}
+
+function normalizeHyperedgeContent(content) {
+  if (content == null) return undefined;
+  if (typeof content === 'string') return { default: content };
+  return content;
+}
+
+
 /**
  * Pre-computes cross-reference and domain edges for each dataset.
  * Reads all concept JSON files, extracts structured references and
@@ -108,7 +132,7 @@ function extractRelated(concept, registerId, uriBase, urnMap) {
     const id = ref['gl:id'] || ref['id'];
     if (!source || !id) continue;
     const reg = urnMap.get(source) || source;
-    const target = `${uriBase}/${reg}/concept/${id}`;
+    const target = buildConceptUri(uriBase, reg, id);
     if (target === sourceUri) continue;
     edges.push({
       source: sourceUri,
@@ -121,6 +145,52 @@ function extractRelated(concept, registerId, uriBase, urnMap) {
   return edges;
 }
 
+/**
+ * Extracts partitive hyperedges from a concept's gl:partitiveHyperedges
+ * array. Returns hyperedge objects (NOT binary GraphEdges) so the UI
+ * can render them with their full set-based semantics: comprehensive +
+ * parts together, enumeration completeness (open vs closed), and
+ * diagram plurality markers (double / dashed).
+ *
+ * Hyperedges are written to a separate hyperedges.json file, keeping
+ * edges.json binary-only.
+ */
+function extractPartitiveHyperedges(concept, registerId, uriBase, urnMap) {
+  const hyperedges = [];
+  const sourceUri = concept['@id'];
+  for (const he of concept['gl:partitiveHyperedges'] || []) {
+    const compRef = he['gl:comprehensive'];
+    if (!compRef) continue;
+    const comprehensive = resolveConceptUri(compRef, uriBase, urnMap);
+    if (!comprehensive) continue;
+
+    const parts = (he['gl:hasPart'] || [])
+      .map(p => resolveConceptUri(p, uriBase, urnMap))
+      .filter(p => p && p !== sourceUri);
+
+    if (parts.length === 0) continue;
+
+    hyperedges.push({
+      source: sourceUri,
+      comprehensive,
+      parts,
+      enumeration: he['gl:enumeration'] || 'closed',
+      markers: validateHyperedgeMarkers(he['gl:hasPluralityMarker'] || []),
+      label: normalizeHyperedgeContent(he['gl:content']),
+      register: registerId,
+    });
+  }
+  return hyperedges;
+}
+
+function resolveConceptUri(ref, uriBase, urnMap) {
+  const source = ref['gl:source'] || ref['source'];
+  const id = ref['gl:id'] || ref['id'];
+  if (!source || !id) return null;
+  const reg = urnMap.get(source) || source;
+  return buildConceptUri(uriBase, reg, id);
+}
+
 const EXTRACTORS = [extractReferences, extractRelated, extractDomains];
 
 function extractAllEdges(concept, registerId, uriBase, urnMap) {
@@ -140,6 +210,7 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
   console.log(`  Processing ${files.length} concepts...`);
 
   const allEdges = [];
+  const allHyperedges = [];
   const allSourceRefs = [];
   const domainConceptCount = new Map();
   let processed = 0;
@@ -149,6 +220,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);
+      allHyperedges.push(...extractPartitiveHyperedges(data, registerId, uriBase, urnMap));
       allSourceRefs.push(...extractSourceRefs(data, registerId));
 
       for (const edge of edges) {
@@ -186,6 +258,17 @@ function buildEdgesForDataset(datasetDir, registerId, uriBase, urnMap, manifest)
   writeFileSync(outputPath, JSON.stringify(output));
   console.log(`  Written ${deduped.length} edges to edges.json (${(JSON.stringify(output).length / 1024).toFixed(1)} KB)`);
 
+  // Write hyperedges.json (parallel to edges.json) for one-to-many
+  // partitive decompositions. See TODO.hyperedge/00-design-overview.md.
+  const hyperedgesOutput = {
+    registerId,
+    hyperedgeCount: allHyperedges.length,
+    hyperedges: allHyperedges,
+  };
+  const hyperedgesPath = join(datasetDir, 'hyperedges.json');
+  writeFileSync(hyperedgesPath, JSON.stringify(hyperedgesOutput));
+  console.log(`  Written ${allHyperedges.length} hyperedges to hyperedges.json (${(JSON.stringify(hyperedgesOutput).length / 1024).toFixed(1)} KB)`);
+
   // Build domain-nodes.json from manifest sections (authoritative source)
   const manifestSections = manifest.sections;
   if (manifestSections && manifestSections.length > 0) {

package/scripts/generate-data.mjs

@@ -14,6 +14,11 @@ import { buildVersionHistoryTurtle } from './lib/version-turtle.mjs';
 import { buildBibliographyTurtle } from './lib/bibliography-turtle.mjs';
 import { ttlLit } from './lib/turtle-escape.mjs';
 import { firstNonEmpty } from './lib/first-non-empty.mjs';
+function buildConceptUri(uriBase, registerId, conceptId) {
+  return `${uriBase}/${registerId}/concept/${conceptId}`;
+}
+
+
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 const ROOT = process.cwd();
 const PUBLIC = path.join(ROOT, 'public');
@@ -60,6 +65,7 @@ function loadConceptFile(filePath) {
 
     // Managed concept-level fields
     if (mc.related) result._related = mc.related;
+    if (mc.partitive_hyperedges) result._partitiveHyperedges = mc.partitive_hyperedges;
     if (mc.data.domains) result._domains = mc.data.domains;
     if (mc.dates) result._dates = mc.dates;
     if (mc.sources) result._sources = mc.sources;
@@ -98,14 +104,14 @@ async function writeDatasetRdf(register, manifest, concepts, refMaps, opts) {
   const datasetIri = `${uriBase}/${register}/`;
   const topConceptUris = concepts
     .slice(0, 32)
-    .map(c => `${uriBase}/${register}/concept/${c.id}`);
+    .map(c => buildConceptUri(uriBase, register, c.id));
 
   const sections = (manifest.sections ?? []).map(section => {
     const sectionId = section.id ?? section.slug ?? section.title;
     return {
       collectionIri: `${uriBase}/${register}/section/${sectionId}`,
       title: section.title ?? section.name ?? sectionId,
-      memberUris: (section.members ?? []).map(id => `${uriBase}/${register}/concept/${id}`),
+      memberUris: (section.members ?? []).map(id => buildConceptUri(uriBase, register, id)),
     };
   });
 
@@ -242,15 +248,16 @@ function defsToJsonLd(defs) {
     .filter(d => d['gl:content']);
 }
 
-function refToJsonLd(ref) {
+function refToJsonLd(ref, typeName = 'gl:Ref') {
   if (!ref) return undefined;
-  const refObj = { '@type': 'gl:Ref' };
+  const refObj = { '@type': typeName };
   if (typeof ref === 'string') {
     refObj['gl:source'] = ref;
   } else {
     if (ref.source) refObj['gl:source'] = ref.source;
     if (ref.id) refObj['gl:id'] = ref.id;
     if (ref.version) refObj['gl:version'] = ref.version;
+    if (ref.text) refObj['gl:text'] = ref.text;
   }
   return refObj;
 }
@@ -366,12 +373,12 @@ function buildPatternIndex(datasets, registerCache) {
 
 function resolveRefUri(term, refMaps) {
   const resolved = refMaps.patternIndex.resolve(term);
-  if (resolved) return `${refMaps.uriBase}/${resolved.datasetId}/concept/${resolved.conceptId}`;
+  if (resolved) return buildConceptUri(refMaps.uriBase, resolved.datasetId, resolved.conceptId);
 
   const ievMatch = term.match(/^IEV:(\d+[-\d]+)$/);
   if (ievMatch) {
     const dsId = refMaps.refPrefixMap['IEV'];
-    if (dsId) return `${refMaps.uriBase}/${dsId}/concept/${ievMatch[1]}`;
+    if (dsId) return buildConceptUri(refMaps.uriBase, dsId, ievMatch[1]);
   }
   return null;
 }
@@ -405,7 +412,7 @@ function resolveIevRef(display, term, refPrefixMap, uriBase) {
   if (!display.startsWith('IEV:')) return null;
   const datasetId = refPrefixMap['IEV'];
   if (!datasetId) return null;
-  return { id: `${uriBase}/${datasetId}/concept/${display.slice(4)}`, term };
+  return { id: buildConceptUri(uriBase, datasetId, display.slice(4)), term };
 }
 
 /**
@@ -414,7 +421,7 @@ function resolveIevRef(display, term, refPrefixMap, uriBase) {
 function resolvePatternRef(identifier, display, refPrefixMap, patternIndex, uriBase) {
   const r = patternIndex.resolve(identifier);
   if (!r) return null;
-  return { id: `${uriBase}/${r.datasetId}/concept/${r.conceptId}`, term: display };
+  return { id: buildConceptUri(uriBase, r.datasetId, r.conceptId), term: display };
 }
 
 /**
@@ -444,7 +451,7 @@ function handleCiteRef(parsed, allSources) {
 function handleNumeric(parsed, register, uriBase) {
   if (!register) return null;
   const term = parsed.label ?? parsed.id;
-  return { id: `${uriBase}/${register}/concept/${parsed.id}`, term };
+  return { id: buildConceptUri(uriBase, register, parsed.id), term };
 }
 
 /**
@@ -459,7 +466,7 @@ function handleDesignation(parsed, refMaps) {
   const display = parsed.label ?? designation;
   const conceptId = refMaps.designationLookup?.get(designation.toLowerCase());
   return {
-    id: `${refMaps.uriBase}/${register}/concept/${conceptId ?? designation}`,
+    id: buildConceptUri(refMaps.uriBase, register, conceptId ?? designation),
     term: display,
   };
 }
@@ -485,7 +492,7 @@ function handleUnresolved(body, refMaps) {
   // Same-dataset: {{conceptId, displayTerm}} where conceptId is numeric/X.Y
   const register = refMaps.register;
   if (register && (/^\d/.test(identifier) || /^[A-Z]\.\d/.test(identifier))) {
-    return { id: `${refMaps.uriBase}/${register}/concept/${identifier}`, term: display };
+    return { id: buildConceptUri(refMaps.uriBase, register, identifier), term: display };
   }
   return null;
 }
@@ -542,7 +549,7 @@ function extractInlineRefs(localizedData, refMaps, conceptSources = []) {
       const term = parsed.label ?? uri;
       const pattern = refMaps.patternIndex.resolve(uri);
       if (pattern) {
-        ref = { id: `${refMaps.uriBase}/${pattern.datasetId}/concept/${pattern.conceptId}`, term };
+        ref = { id: buildConceptUri(refMaps.uriBase, pattern.datasetId, pattern.conceptId), term };
       } else {
         ref = { id: uri, term };
       }
@@ -571,7 +578,7 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
   const base = refMaps.uriBase;
   const doc = {
     '@context': 'https://glossarist.org/ns/context.jsonld',
-    '@id': `${base}/${register}/concept/${termid}`,
+    '@id': buildConceptUri(base, register, termid),
     '@type': 'gl:Concept',
     'gl:identifier': termid,
   };
@@ -672,6 +679,28 @@ function yamlToJsonLd(conceptYaml, register, refMaps) {
     });
   }
 
+  if (conceptYaml._partitiveHyperedges?.length > 0) {
+    doc['gl:partitiveHyperedges'] = conceptYaml._partitiveHyperedges.map(he => {
+      const out = { '@type': 'gl:PartitiveHyperedge' };
+      if (he.comprehensive) {
+        out['gl:comprehensive'] = refToJsonLd(he.comprehensive, 'gl:ConceptRef');
+      }
+      if (Array.isArray(he.parts) && he.parts.length > 0) {
+        out['gl:hasPart'] = he.parts.map(p => refToJsonLd(p, 'gl:ConceptRef'));
+      }
+      if (he.enumeration) {
+        out['gl:enumeration'] = he.enumeration;
+      }
+      if (Array.isArray(he.markers) && he.markers.length > 0) {
+        out['gl:hasPluralityMarker'] = [...he.markers];
+      }
+      if (he.content) {
+        out['gl:content'] = typeof he.content === 'string' ? { default: he.content } : he.content;
+      }
+      return out;
+    });
+  }
+
   return doc;
 }
 
@@ -920,6 +949,61 @@ async function processDataset(dir, register, opts) {
 
   const dsRefMaps = { ...refMaps, register, designationLookup };
 
+  const stats = {
+    sourceMap: new Map(),
+    relTypeCounts: {},
+    partitiveHyperedges: { count: 0, byEnumeration: { closed: 0, open: 0 }, byMarker: { double: 0, dashed: 0, none: 0 } },
+  };
+
+  const STATS_PROCESSORS = [
+    function collectSources(cy, termid, s) {
+      const refs = new Set();
+      const allSources = [
+        ...(cy._sources || []),
+        ...opts.languages.flatMap(l => cy[l]?.sources || []),
+      ];
+      for (const src of allSources) {
+        const ref = src.origin?.ref?.source || src.origin?.ref?.id || 'Unknown';
+        refs.add(ref);
+        if (!s.sourceMap.has(ref)) s.sourceMap.set(ref, { ref, types: new Set(), conceptIds: [] });
+        if (src.type) s.sourceMap.get(ref).types.add(src.type);
+      }
+      for (const ref of refs) s.sourceMap.get(ref)?.conceptIds.push(termid);
+    },
+    function countRelationships(cy, _termid, s) {
+      for (const r of cy._related || []) {
+        const type = r.type || 'unknown';
+        s.relTypeCounts[type] = (s.relTypeCounts[type] || 0) + 1;
+      }
+    },
+    function countHyperedges(cy, _termid, s) {
+      for (const he of cy._partitiveHyperedges || []) {
+        s.partitiveHyperedges.count += 1;
+        const e = he.enumeration || 'closed';
+        s.partitiveHyperedges.byEnumeration[e] = (s.partitiveHyperedges.byEnumeration[e] || 0) + 1;
+        const markers = he.markers || [];
+        if (markers.length === 0) {
+          s.partitiveHyperedges.byMarker.none += 1;
+        } else {
+          for (const m of markers) {
+            s.partitiveHyperedges.byMarker[m] = (s.partitiveHyperedges.byMarker[m] || 0) + 1;
+          }
+        }
+      }
+    },
+    function countLanguages(cy, _termid, _s) {
+      for (const lang of opts.languages) {
+        const lc = cy[lang];
+        if (lc) {
+          if (lc.terms?.length > 0) langTermCounts[lang] = (langTermCounts[lang] || 0) + 1;
+          if (lc.definition && (Array.isArray(lc.definition) ? lc.definition.some(d => d.content) : lc.definition)) {
+            langDefCounts[lang] = (langDefCounts[lang] || 0) + 1;
+          }
+        }
+      }
+    },
+  ];
+
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
     try {
@@ -930,21 +1014,17 @@ async function processDataset(dir, register, opts) {
       const jsonld = yamlToJsonLd(conceptYaml, register, dsRefMaps);
       writeJson(path.join(conceptsDir, `${termid}.json`), jsonld);
 
-      // Generate Turtle format
       const ttlContent = conceptJsonToTurtle(jsonld);
       fs.writeFileSync(path.join(conceptsDir, `${termid}.ttl`), ttlContent);
 
-      // Generate SKOS JSON-LD format
       const skosJsonLd = conceptJsonToSkosJsonLd(jsonld);
       fs.writeFileSync(path.join(conceptsDir, `${termid}.jsonld`), skosJsonLd);
 
-      // Generate TBX-XML format
       const tbxContent = conceptJsonToTbx(jsonld);
       if (tbxContent) {
         fs.writeFileSync(path.join(conceptsDir, `${termid}.tbx`), tbxContent);
       }
 
-      // Copy source YAML
       fs.copyFileSync(path.join(dir, file), path.join(conceptsDir, `${termid}.yaml`));
 
       concepts.push({
@@ -954,16 +1034,8 @@ async function processDataset(dir, register, opts) {
         status: conceptYaml.eng?.entry_status || 'valid',
       });
 
-      for (const lang of opts.languages) {
-        const lc = conceptYaml[lang];
-        if (lc) {
-          if (lc.terms && lc.terms.length > 0) {
-            langTermCounts[lang] = (langTermCounts[lang] || 0) + 1;
-          }
-          if (lc.definition && (Array.isArray(lc.definition) ? lc.definition.some(d => d.content) : lc.definition)) {
-            langDefCounts[lang] = (langDefCounts[lang] || 0) + 1;
-          }
-        }
+      for (const processor of STATS_PROCESSORS) {
+        processor(conceptYaml, termid, stats);
       }
     } catch (e) {
       console.warn(`  Skipping ${file}: ${e.message}`);
@@ -1072,6 +1144,24 @@ async function processDataset(dir, register, opts) {
     }
   }
 
+  const sourceStats = Array.from(stats.sourceMap.values())
+    .map(s => ({
+      ref: s.ref,
+      types: Array.from(s.types),
+      conceptCount: s.conceptIds.length,
+      conceptIds: s.conceptIds,
+    }))
+    .sort((a, b) => b.conceptCount - a.conceptCount);
+  const totalRelationships = Object.values(stats.relTypeCounts).reduce((a, b) => a + b, 0);
+
+  writeJson(path.join(DATA, register, 'stats.json'), {
+    sourceCount: sourceStats.length,
+    sources: sourceStats,
+    relationshipCount: totalRelationships,
+    relationshipTypes: stats.relTypeCounts,
+    partitiveHyperedges: stats.partitiveHyperedges,
+  });
+
   const manifest = {
     id: register,
     datasetUri: opts.datasetUri,
@@ -1082,6 +1172,8 @@ async function processDataset(dir, register, opts) {
     baseUrl: `/data/${register}`,
     languages: opts.languages,
     conceptCount: concepts.length,
+    sourceCount: sourceStats.length,
+    relationshipCount: totalRelationships,
     conceptUrlTemplate: '{baseUrl}/concepts/{conceptId}.json',
     indexUrl: '{baseUrl}/index.json',
     contextUrl: 'https://glossarist.org/ns/context.jsonld',

package/src/__tests__/hyperedge-styling.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { hyperedgeStyle, markerColor, enumerationLabel } from '../utils/hyperedge-styling';
+
+describe('hyperedge-styling', () => {
+  describe('hyperedgeStyle', () => {
+    it('returns full opacity for closed enumeration', () => {
+      expect(hyperedgeStyle('closed', [], false).opacity).toBe(1.0);
+    });
+
+    it('returns reduced opacity for open enumeration', () => {
+      expect(hyperedgeStyle('open', [], false).opacity).toBe(0.6);
+    });
+
+    it('uses teal badge class for closed with no markers', () => {
+      expect(hyperedgeStyle('closed', [], false).badgeClass).toBe('badge-teal');
+    });
+
+    it('uses blue badge class for double marker', () => {
+      expect(hyperedgeStyle('closed', ['double'], false).badgeClass).toBe('badge-blue');
+    });
+
+    it('uses yellow badge class for dashed marker', () => {
+      expect(hyperedgeStyle('closed', ['dashed'], false).badgeClass).toBe('badge-yellow');
+    });
+
+    it('returns different colors in dark mode', () => {
+      const light = hyperedgeStyle('closed', [], false);
+      const dark = hyperedgeStyle('closed', [], true);
+      expect(light.color).not.toBe(dark.color);
+    });
+  });
+
+  describe('markerColor', () => {
+    it('returns blue for double marker', () => {
+      expect(markerColor('double', false)).toBe('#3b82f6');
+    });
+
+    it('returns amber for dashed marker', () => {
+      expect(markerColor('dashed', false)).toBe('#f59e0b');
+    });
+
+    it('returns dark-mode variants', () => {
+      expect(markerColor('double', true)).toBe('#60a5fa');
+      expect(markerColor('dashed', true)).toBe('#fbbf24');
+    });
+  });
+
+  describe('enumerationLabel', () => {
+    it('labels closed as "Closed (complete)"', () => {
+      expect(enumerationLabel('closed')).toBe('Closed (complete)');
+    });
+
+    it('labels open as "Open (partial)"', () => {
+      expect(enumerationLabel('open')).toBe('Open (partial)');
+    });
+  });
+});