@glossarist/concept-browser 0.7.77 → 0.7.80

package/src/__tests__/ontology-registry.test.ts

@@ -3,12 +3,12 @@ import { ontology } from '../adapters/ontology-registry';
 
 describe('OntologyRegistry', () => {
   it('loads all 10 taxonomies', () => {
-    expect(ontology.getAll('conceptStatus').length).toBe(7);
+    expect(ontology.getAll('conceptStatus').length).toBe(8);
     expect(ontology.getAll('entryStatus').length).toBe(4);
     expect(ontology.getAll('normativeStatus').length).toBe(4);
     expect(ontology.getAll('sourceType').length).toBe(2);
     expect(ontology.getAll('sourceStatus').length).toBe(10);
-    expect(ontology.getAll('relationshipType').length).toBe(52);
+    expect(ontology.getAll('relationshipType').length).toBe(54);
     expect(ontology.getAll('designationType').length).toBe(5);
     expect(ontology.getAll('termType').length).toBe(24);
     expect(ontology.getAll('grammarGender').length).toBe(4);

package/src/__tests__/partitive-relation-styling.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import {
+  partitiveRelationStyle,
+  pluralityColor,
+  completenessLabel,
+  certaintyLabel,
+} from '../utils/partitive-relation-styling';
+import type { TypeSharedPluralityWire } from '../adapters/types';
+
+describe('partitive-relation-styling', () => {
+  describe('partitiveRelationStyle', () => {
+    it('returns full opacity for complete', () => {
+      expect(partitiveRelationStyle('complete', null, false).opacity).toBe(1.0);
+    });
+
+    it('returns reduced opacity for partial', () => {
+      expect(partitiveRelationStyle('partial', null, false).opacity).toBe(0.6);
+    });
+
+    it('uses teal badge class for complete with no plurality', () => {
+      expect(partitiveRelationStyle('complete', null, false).badgeClass).toBe('badge-teal');
+    });
+
+    it('uses blue badge class for isShared plurality', () => {
+      const p: TypeSharedPluralityWire = { isShared: true, isUncertain: false };
+      expect(partitiveRelationStyle('complete', p, false).badgeClass).toBe('badge-blue');
+    });
+
+    it('uses yellow badge class when isShared + isUncertain', () => {
+      const p: TypeSharedPluralityWire = { isShared: true, isUncertain: true };
+      expect(partitiveRelationStyle('complete', p, false).badgeClass).toBe('badge-yellow');
+    });
+
+    it('returns different colors in dark mode', () => {
+      const light = partitiveRelationStyle('complete', null, false);
+      const dark = partitiveRelationStyle('complete', null, true);
+      expect(light.color).not.toBe(dark.color);
+    });
+
+    it('ignores plurality when isShared is false', () => {
+      const p: TypeSharedPluralityWire = { isShared: false, isUncertain: true };
+      expect(partitiveRelationStyle('complete', p, false).badgeClass).toBe('badge-teal');
+    });
+  });
+
+  describe('pluralityColor', () => {
+    it('returns blue for isShared', () => {
+      const p: TypeSharedPluralityWire = { isShared: true, isUncertain: false };
+      expect(pluralityColor(p, false)).toBe('#3b82f6');
+    });
+
+    it('returns amber when isUncertain', () => {
+      const p: TypeSharedPluralityWire = { isShared: true, isUncertain: true };
+      expect(pluralityColor(p, false)).toBe('#f59e0b');
+    });
+
+    it('returns dark-mode variants', () => {
+      expect(pluralityColor({ isShared: true, isUncertain: false }, true)).toBe('#60a5fa');
+      expect(pluralityColor({ isShared: true, isUncertain: true }, true)).toBe('#fbbf24');
+    });
+  });
+
+  describe('completenessLabel', () => {
+    it('labels complete', () => {
+      expect(completenessLabel('complete')).toBe('Complete');
+    });
+
+    it('labels partial', () => {
+      expect(completenessLabel('partial')).toBe('Partial');
+    });
+  });
+
+  describe('certaintyLabel', () => {
+    it('labels confirmed', () => {
+      expect(certaintyLabel('confirmed')).toBe('Confirmed');
+    });
+
+    it('labels possible', () => {
+      expect(certaintyLabel('possible')).toBe('Possible');
+    });
+  });
+});

package/src/__tests__/partitive-relation.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect } from 'vitest';
+import type { PartitiveRelationWire } from '../adapters/types';
+
+// Re-implements the extractor under test so we can test it in isolation
+// without spinning up the full build-edges.js pipeline. The production
+// extractor in scripts/build-edges.js uses the same logic.
+function extractPartitiveRelations(
+  concept: { '@id': string; 'gl:partitiveRelations'?: any[] },
+  registerId: string,
+  uriBase: string,
+  urnMap: Map<string, string>,
+): PartitiveRelationWire[] {
+  const relations: PartitiveRelationWire[] = [];
+  const sourceUri = concept['@id'];
+
+  const resolveConceptUri = (ref: any): string | null => {
+    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 `${uriBase}/${reg}/concept/${id}`;
+  };
+
+  const resolvePlurality = (plurality: any) => {
+    if (!plurality) return null;
+    const isShared = plurality['gl:isShared'] ?? plurality.is_shared;
+    if (typeof isShared !== 'boolean') return null;
+    const isUncertain = plurality['gl:isUncertain'] ?? plurality.is_uncertain ?? false;
+    const sharedTypeRef = plurality['gl:sharedType'] ?? plurality.shared_type;
+    let sharedType = null;
+    if (sharedTypeRef) {
+      const s = sharedTypeRef['gl:source'] ?? sharedTypeRef.source;
+      const i = sharedTypeRef['gl:id'] ?? sharedTypeRef.id;
+      if (s && i) sharedType = `${s}:${i}`;
+    }
+    return { isShared, isUncertain, sharedType };
+  };
+
+  for (const rel of concept['gl:partitiveRelations'] || []) {
+    const comprehensive = resolveConceptUri(rel['gl:comprehensive']);
+    if (!comprehensive) continue;
+    const partitives = (rel['gl:hasPartitive'] || [])
+      .map((member: any) => {
+        const ref = member['gl:ref'] || member;
+        const uri = resolveConceptUri(ref);
+        if (!uri || uri === sourceUri) return null;
+        const certainty = member['gl:certainty'] || 'confirmed';
+        if (certainty !== 'confirmed' && certainty !== 'possible') {
+          throw new Error(
+            `Invalid partitive member certainty: "${certainty}". Allowed: confirmed, possible`,
+          );
+        }
+        return { uri, certainty };
+      })
+      .filter((p: any): p is { uri: string; certainty: 'confirmed' | 'possible' } => p !== null);
+    if (partitives.length === 0) continue;
+    const completeness = rel['gl:completeness'] || 'complete';
+    if (completeness !== 'complete' && completeness !== 'partial') {
+      throw new Error(
+        `Invalid partitive relation completeness: "${completeness}". Allowed: complete, partial`,
+      );
+    }
+    relations.push({
+      source: sourceUri,
+      comprehensive,
+      partitives,
+      completeness,
+      plurality: resolvePlurality(rel['gl:hasPlurality']) as PartitiveRelationWire['plurality'],
+      criterion: rel['gl:criterion'],
+      register: registerId,
+    });
+  }
+  return relations;
+}
+
+describe('extractPartitiveRelations', () => {
+  const uriBase = 'https://example.org';
+  const urnMap = new Map([['urn:vim:pub:v:2:2012', 'vim-2012']]);
+  const registerId = 'vim-2012';
+  const sourceUri = `${uriBase}/${registerId}/concept/2.9`;
+
+  it('extracts a complete relation with two confirmed members', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' } },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.26' } },
+          ],
+          'gl:completeness': 'complete',
+          'gl:criterion': { eng: 'measurement result composition' },
+        },
+      ],
+    };
+
+    const result = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(result).toHaveLength(1);
+    expect(result[0].comprehensive).toBe(`${uriBase}/${registerId}/concept/2.9`);
+    expect(result[0].partitives).toEqual([
+      { uri: `${uriBase}/${registerId}/concept/2.10`, certainty: 'confirmed' },
+      { uri: `${uriBase}/${registerId}/concept/2.26`, certainty: 'confirmed' },
+    ]);
+    expect(result[0].completeness).toBe('complete');
+    expect(result[0].criterion).toEqual({ eng: 'measurement result composition' });
+  });
+
+  it('defaults completeness to complete when omitted', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' } },
+          ],
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.completeness).toBe('complete');
+  });
+
+  it('preserves partial completeness', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+          'gl:completeness': 'partial',
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.completeness).toBe('partial');
+  });
+
+  it('resolves plurality block (isShared + sharedType)', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+          'gl:hasPlurality': {
+            'gl:isShared': true,
+            'gl:isUncertain': false,
+            'gl:sharedType': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.99' },
+          },
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.plurality).toEqual({
+      isShared: true,
+      isUncertain: false,
+      sharedType: 'urn:vim:pub:v:2:2012:1.99',
+    });
+  });
+
+  it('returns null plurality when isShared missing', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+          'gl:hasPlurality': { 'gl:isUncertain': true },
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.plurality).toBeNull();
+  });
+
+  it('preserves per-member certainty', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.5' }, 'gl:certainty': 'possible' },
+          ],
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.partitives).toEqual([
+      { uri: `${uriBase}/${registerId}/concept/1.4`, certainty: 'confirmed' },
+      { uri: `${uriBase}/${registerId}/concept/1.5`, certainty: 'possible' },
+    ]);
+  });
+
+  it('throws on invalid completeness', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+          'gl:completeness': 'closed',
+        },
+      ],
+    };
+    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*completeness.*closed/);
+  });
+
+  it('throws on invalid member certainty', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' }, 'gl:certainty': 'maybe' },
+          ],
+        },
+      ],
+    };
+    expect(() => extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toThrow(/Invalid.*certainty.*maybe/);
+  });
+
+  it('skips a relation whose comprehensive cannot be resolved', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:id': '1.3' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '1.4' } },
+          ],
+        },
+      ],
+    };
+    expect(extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toHaveLength(0);
+  });
+
+  it('skips a relation with no resolvable partitives', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPartitive': [{ 'gl:ref': { 'gl:id': '1.4' } }],
+        },
+      ],
+    };
+    expect(extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toHaveLength(0);
+  });
+
+  it('excludes the source concept from partitives (self-loop guard)', () => {
+    const concept = {
+      '@id': sourceUri,
+      'gl:partitiveRelations': [
+        {
+          'gl:comprehensive': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' },
+          'gl:hasPartitive': [
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.10' } },
+            { 'gl:ref': { 'gl:source': 'urn:vim:pub:v:2:2012', 'gl:id': '2.9' } },
+          ],
+        },
+      ],
+    };
+    const [rel] = extractPartitiveRelations(concept, registerId, uriBase, urnMap);
+    expect(rel.partitives).toHaveLength(1);
+    expect(rel.partitives[0].uri).toBe(`${uriBase}/${registerId}/concept/2.10`);
+  });
+
+  it('returns empty array when concept has no partitiveRelations', () => {
+    const concept = { '@id': sourceUri };
+    expect(extractPartitiveRelations(concept, registerId, uriBase, urnMap)).toEqual([]);
+  });
+});

package/src/__tests__/sphere-math.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import { hashSeed, expandParams, portSide, portPoint, idToUriGet } from '../utils/sphere-math';
+
+describe('sphere-math', () => {
+  describe('hashSeed', () => {
+    it('produces deterministic positive integers', () => {
+      expect(hashSeed('abc')).toBe(hashSeed('abc'));
+      expect(hashSeed('abc')).not.toBe(hashSeed('abd'));
+      expect(hashSeed('')).toBeGreaterThanOrEqual(0);
+      expect(hashSeed('test')).toBeGreaterThan(0);
+    });
+  });
+
+  describe('expandParams', () => {
+    it('clamps to [0, 10] and maps to physical constants', () => {
+      const min = expandParams(0);
+      const max = expandParams(10);
+      expect(min.linkDist).toBeLessThan(max.linkDist);
+      expect(min.repMin).toBeLessThan(max.repMin);
+    });
+
+    it('clamps out-of-range values', () => {
+      expect(expandParams(-5)).toEqual(expandParams(0));
+      expect(expandParams(20)).toEqual(expandParams(10));
+    });
+  });
+
+  describe('portSide', () => {
+    it('determines the dominant axis direction', () => {
+      expect(portSide({ x: 0, y: 0 }, { x: 10, y: 0 })).toBe('right');
+      expect(portSide({ x: 0, y: 0 }, { x: -10, y: 0 })).toBe('left');
+      expect(portSide({ x: 0, y: 0 }, { x: 0, y: 10 })).toBe('bottom');
+      expect(portSide({ x: 0, y: 0 }, { x: 0, y: -10 })).toBe('top');
+    });
+  });
+
+  describe('portPoint', () => {
+    it('computes the connection point on each side', () => {
+      const c = { x: 100, y: 100 };
+      const w = 220, h = 60;
+      const right = portPoint(c, 'right', w, h, 0);
+      expect(right.x).toBe(210);
+      expect(right.y).toBe(100);
+      const top = portPoint(c, 'top', w, h, 0);
+      expect(top.y).toBe(70);
+    });
+  });
+
+  describe('idToUriGet', () => {
+    it('reverse-looks-up a URI in an ID→URI map', () => {
+      const map = new Map([['a', '/uri/a'], ['b', '/uri/b']]);
+      expect(idToUriGet(map, '/uri/b')).toBe('b');
+      expect(idToUriGet(map, '/uri/unknown')).toBeUndefined();
+    });
+  });
+});

package/src/adapters/GraphDataSource.ts

@@ -1,4 +1,4 @@
-import type { GraphEdge, GraphNode, SectionNode } from './types';
+import type { GraphEdge, GraphNode, PartitiveRelationWire, SectionNode } from './types';
 import type { Concept, RelatedConcept } from 'glossarist';
 import type { DatasetAdapter } from './DatasetAdapter';
 import { UriRouter } from './UriRouter';
@@ -30,6 +30,16 @@ function resolveRefTarget(rc: RelatedConcept, uriBase: string, registerId: strin
   return ref.source || '';
 }
 
+function contentLabel(content: unknown): string | undefined {
+  if (content == null) return undefined;
+  if (typeof content === 'string') return content;
+  if (typeof content === 'object' && content !== null) {
+    const obj = content as Record<string, string>;
+    return obj.default ?? obj.eng ?? Object.values(obj)[0];
+  }
+  return undefined;
+}
+
 export class GraphDataSource {
   constructor(private adapter: DatasetAdapter) {}
 
@@ -58,6 +68,13 @@ export class GraphDataSource {
     return data.edges ?? [];
   }
 
+  async loadPartitiveRelations(): Promise<PartitiveRelationWire[]> {
+    const resp = await fetch(`${this.baseUrl}/partitive_relations.json`);
+    if (!resp.ok) return [];
+    const data = await resp.json();
+    return data.relations ?? data.hyperedges ?? [];
+  }
+
   async loadGraphNodes(): Promise<{ uriPrefix: string; nodes: [string, Record<string, string>, string][] }> {
     const resp = await fetch(`${this.baseUrl}/graph-nodes.json`);
     if (!resp.ok) return { uriPrefix: '', nodes: [] };
@@ -73,7 +90,7 @@ export class GraphDataSource {
 
   extractEdges(concept: Concept): GraphEdge[] {
     const edges: GraphEdge[] = [];
-    const sourceUri = concept.uri || `${this.uriBase}/${this.registerId}/concept/${concept.id}`;
+    const sourceUri = concept.uri || UriRouter.buildConceptUri(this.uriBase, this.registerId, concept.id);
 
     for (const rc of concept.relatedConcepts) {
       const target = resolveRefTarget(rc, this.uriBase, this.registerId, this.urnMap);
@@ -83,7 +100,7 @@ export class GraphDataSource {
           source: sourceUri,
           target,
           type: rc.type || 'references',
-          label: rc.content || undefined,
+          label: contentLabel(rc.content),
           register: parsed?.registerId ?? this.registerId,
         });
       }
@@ -100,7 +117,7 @@ export class GraphDataSource {
             source: sourceUri,
             target,
             type: rc.type || 'references',
-            label: rc.content || undefined,
+            label: contentLabel(rc.content),
             register: parsed?.registerId ?? this.registerId,
             lang,
           });
@@ -113,7 +130,7 @@ export class GraphDataSource {
 
   extractDomainEdges(concept: Concept): GraphEdge[] {
     const edges: GraphEdge[] = [];
-    const sourceUri = concept.uri || `${this.uriBase}/${this.registerId}/concept/${concept.id}`;
+    const sourceUri = concept.uri || UriRouter.buildConceptUri(this.uriBase, this.registerId, concept.id);
 
     for (const lang of concept.languages) {
       const lc = concept.localization(lang);

package/src/adapters/UriRouter.ts

@@ -101,6 +101,11 @@ export class UriRouter {
     return m ? { registerId: m[1], conceptId: m[2] } : null;
   }
 
+  /** Construct a canonical concept URI from components. */
+  static buildConceptUri(uriBase: string, registerId: string, conceptId: string): string {
+    return `${uriBase}/${registerId}/concept/${conceptId}`;
+  }
+
   /** Construct a canonical URI for a concept. */
   buildUri(registerId: string, conceptId: string): string {
     const info = this.registerMap.get(registerId);

package/src/adapters/dataset-stats.ts

@@ -0,0 +1,13 @@
+/**
+ * Dataset-level stats shape. The data pipeline emits this as
+ * `public/data/{registerId}/stats.json`. Consumers fetch via HTTP.
+ *
+ * Kept in adapters/types.ts (the SSOT for wire shapes) so all views
+ * that need stats share the same definition.
+ */
+export interface DatasetStats {
+  sourceCount: number;
+  sources: Array<{ ref: string; types: string[]; conceptCount: number }>;
+  relationshipCount: number;
+  relationshipTypes: Record<string, number>;
+}

package/src/adapters/model-bridge.ts

@@ -287,7 +287,7 @@ function attachBridges(concept: Concept, localizations: Record<string, unknown>)
  * instances, since RelatedConcept.fromJSON only reads type/content/ref.
  */
 function attachRelatedBridges(
-  modelRelated: Array<{ type?: string | null; content?: string | null; ref?: any; related?: any[] }>,
+  modelRelated: Array<{ type?: string | null; content?: Record<string, string> | string | null; ref?: any; related?: any[] }>,
   rawRelated: unknown[],
 ): void {
   for (const rawRel of rawRelated) {