@glossarist/concept-browser 0.3.4 → 0.4.0

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

@@ -19,6 +19,8 @@ class MockPlurimath {
 import { vMath } from '../directives/v-math';
 import { loadPlurimath, mathToHtml } from '../utils/plurimath';
 
+const directive = vMath as import('vue').ObjectDirective<HTMLElement>;
+
 describe('v-math directive', () => {
   let container: HTMLElement;
 
@@ -29,21 +31,20 @@ describe('v-math directive', () => {
 
   it('does nothing when no math-pending elements exist', () => {
     container.innerHTML = '<p>plain text</p>';
-    vMath.mounted!(container, {} as any);
+    directive.mounted!(container, {} as any, {} as any, {} as any);
     expect(container.innerHTML).toBe('<p>plain text</p>');
   });
 
   it('triggers loadPlurimath when math-pending elements exist', async () => {
     container.innerHTML = '<span class="math-pending" data-expr="x^2" data-format="asciimath">x^2</span>';
-    vMath.mounted!(container, {} as any);
+    directive.mounted!(container, {} as any, {} as any, {} as any);
     expect(loadPlurimath).toHaveBeenCalled();
   });
 
   it('replaces math-pending elements after loading', async () => {
     container.innerHTML = '<span class="math-pending" data-expr="x^2" data-format="asciimath">x^2</span>';
-    vMath.mounted!(container, {} as any);
+    directive.mounted!(container, {} as any, {} as any, {} as any);
 
-    // Wait for loadPlurimath promise to resolve and upgrade to run
     await vi.waitFor(() => {
       expect(mathToHtml).toHaveBeenCalledWith('x^2', 'asciimath', false);
     });
@@ -51,7 +52,7 @@ describe('v-math directive', () => {
 
   it('handles bold math-pending elements', async () => {
     container.innerHTML = '<span class="math-pending math-bold" data-expr="alpha" data-format="asciimath">alpha</span>';
-    vMath.mounted!(container, {} as any);
+    directive.mounted!(container, {} as any, {} as any, {} as any);
 
     await vi.waitFor(() => {
       expect(mathToHtml).toHaveBeenCalledWith('alpha', 'asciimath', true);
@@ -60,7 +61,7 @@ describe('v-math directive', () => {
 
   it('skips elements without data-expr', async () => {
     container.innerHTML = '<span class="math-pending">no expr</span>';
-    vMath.mounted!(container, {} as any);
+    directive.mounted!(container, {} as any, {} as any, {} as any);
 
     await vi.waitFor(() => {
       expect(mathToHtml).not.toHaveBeenCalled();
@@ -69,7 +70,7 @@ describe('v-math directive', () => {
 
   it('uses default format asciimath when data-format is missing', async () => {
     container.innerHTML = '<span class="math-pending" data-expr="x">x</span>';
-    vMath.mounted!(container, {} as any);
+    directive.mounted!(container, {} as any, {} as any, {} as any);
 
     await vi.waitFor(() => {
       expect(mathToHtml).toHaveBeenCalledWith('x', 'asciimath', false);

package/src/adapters/DatasetAdapter.ts

@@ -3,12 +3,29 @@ import type {
   ConceptIndex,
   ConceptSummary,
   ConceptEntry,
-  ConceptDocument,
   SearchHit,
   GraphEdge,
+  GraphNode,
 } from './types';
+import type { Concept, LocalizedConcept, Designation } from 'glossarist';
+import { conceptFromJson, conceptUri } from './model-bridge';
 import { UriRouter } from './UriRouter';
 
+function slugify(text: string): string {
+  return text.toLowerCase().replace(/[^\w\s-]/g, '').replace(/[\s/]+/g, '-');
+}
+
+function resolveRefTarget(rc: any, uriBase: string, registerId: string): string {
+  if (!rc.ref) return '';
+  const ref = rc.ref;
+  if (ref.id) {
+    const reg = (ref.source && !ref.source.startsWith('http')) ? ref.source : registerId;
+    return `${uriBase}/${reg}/concept/${ref.id}`;
+  }
+  if (ref.source && ref.source.startsWith('http')) return ref.source;
+  return ref.source || '';
+}
+
 export class DatasetAdapter {
   private positionIndex = new Map<string, number>();
   readonly registerId: string;
@@ -16,7 +33,7 @@ export class DatasetAdapter {
   manifest: Manifest | null = null;
   index: ConceptIndex | null = null;
 
-  private conceptCache = new Map<string, ConceptDocument>();
+  private conceptCache = new Map<string, Concept>();
   private summaryMap = new Map<string, ConceptSummary>();
   private loadedChunks = new Set<number>();
   private indexMeta: { conceptCount: number; chunkSize: number; chunks: { file: string; count: number }[] } | null = null;
@@ -43,14 +60,53 @@ export class DatasetAdapter {
 
     const resp = await fetch(`${this.baseUrl}/index.json`);
     if (!resp.ok) throw new Error(`Failed to load index for ${this.registerId}: ${resp.status}`);
-    this.index = (await resp.json()) as ConceptIndex;
+    const data = await resp.json();
+
+    // Handle both old format (with eng/status fields) and new format (with designations map)
+    this.index = this.normalizeIndex(data);
+    this.buildSummaryIndex();
+    return this.index;
+  }
+
+  private normalizeIndex(data: any): ConceptIndex {
+    const concepts: ConceptSummary[] = (data.concepts || []).map((c: any) => {
+      if (c.designations && typeof c.designations === 'object') {
+        return {
+          id: c.id,
+          designations: c.designations,
+          eng: c.eng || c.designations.eng || Object.values(c.designations)[0] || '',
+          status: c.status,
+        };
+      }
+      // Legacy format: c.eng is a string, no designations map
+      return {
+        id: c.id,
+        designations: c.eng ? { eng: c.eng } : {},
+        eng: c.eng || '',
+        status: c.status,
+      };
+    });
+
+    return {
+      registerId: data.registerId,
+      schemaVersion: data.schemaVersion,
+      conceptCount: data.conceptCount,
+      chunkSize: data.chunkSize,
+      chunks: data.chunks || [],
+      concepts,
+    };
+  }
+
+  private buildSummaryIndex() {
     this.summaryMap.clear();
     this.positionIndex.clear();
-    for (let i = 0; i < this.index.concepts.length; i++) {
-      this.summaryMap.set(this.index.concepts[i].id, this.index.concepts[i]);
-      this.positionIndex.set(this.index.concepts[i].id, i);
+    for (let i = 0; i < this.index!.concepts.length; i++) {
+      const entry = this.index!.concepts[i];
+      if (entry) {
+        this.summaryMap.set(entry.id, entry);
+        this.positionIndex.set(entry.id, i);
+      }
     }
-    return this.index;
   }
 
   private async loadIndexChunked(): Promise<ConceptIndex> {
@@ -61,13 +117,9 @@ export class DatasetAdapter {
     } else {
       const resp = await fetch(`${this.baseUrl}/index.json`);
       if (!resp.ok) throw new Error(`Failed to load index for ${this.registerId}`);
-      this.index = (await resp.json()) as ConceptIndex;
-      this.summaryMap.clear();
-      this.positionIndex.clear();
-      for (let i = 0; i < this.index.concepts.length; i++) {
-        this.summaryMap.set(this.index.concepts[i].id, this.index.concepts[i]);
-        this.positionIndex.set(this.index.concepts[i].id, i);
-      }
+      const data = await resp.json();
+      this.index = this.normalizeIndex(data);
+      this.buildSummaryIndex();
       return this.index;
     }
 
@@ -77,7 +129,6 @@ export class DatasetAdapter {
       chunks: meta.chunks,
     };
 
-    // Pre-allocate array so positions match concept order — undefined = not loaded yet
     this.index = {
       registerId: meta.registerId,
       schemaVersion: meta.schemaVersion,
@@ -88,7 +139,6 @@ export class DatasetAdapter {
     };
 
     await this.loadChunkAsSummaries(0);
-
     return this.index;
   }
 
@@ -116,12 +166,14 @@ export class DatasetAdapter {
 
     for (let i = 0; i < entries.length; i++) {
       const entry = entries[i];
+      const designations = entry.designations || (entry.groups ? {} : { eng: '' });
       const summary: ConceptSummary = {
         id: entry.id,
-        eng: entry.designations?.eng || Object.values(entry.designations || {})[0] || '',
+        designations,
+        eng: designations.eng || Object.values(designations)[0] || '',
         status: entry.status,
       };
-      (this.index!.concepts as (ConceptSummary | undefined)[])[startPos + i] = summary;
+      this.index!.concepts[startPos + i] = summary;
       this.summaryMap.set(entry.id, summary);
       this.positionIndex.set(entry.id, startPos + i);
     }
@@ -144,7 +196,6 @@ export class DatasetAdapter {
     if (!this.indexMeta) return;
     const { chunks } = this.indexMeta;
     const toLoad = chunks.map((_, i) => i).filter(i => !this.loadedChunks.has(i));
-    // Load in parallel batches of 5 to avoid overwhelming the browser
     for (let i = 0; i < toLoad.length; i += 5) {
       const batch = toLoad.slice(i, i + 5);
       await Promise.all(batch.map(c => this.loadChunkAsSummaries(c)));
@@ -153,29 +204,30 @@ export class DatasetAdapter {
 
   isRangeLoaded(offset: number, limit: number): boolean {
     if (!this.index?.concepts) return false;
-    const arr = this.index.concepts as (ConceptSummary | undefined)[];
+    const arr = this.index.concepts;
     for (let i = offset; i < Math.min(offset + limit, arr.length); i++) {
       if (arr[i] === undefined) return false;
     }
     return true;
   }
 
-  async fetchConcept(conceptId: string): Promise<ConceptDocument> {
+  async fetchConcept(conceptId: string): Promise<Concept> {
     const cached = this.conceptCache.get(conceptId);
     if (cached) return cached;
 
     const resp = await fetch(`${this.baseUrl}/concepts/${conceptId}.json`);
     if (!resp.ok) throw new Error(`Concept ${conceptId} not found in ${this.registerId}`);
-    const doc = (await resp.json()) as ConceptDocument;
-    this.conceptCache.set(conceptId, doc);
-    return doc;
+    const json = await resp.json();
+    const concept = conceptFromJson(json);
+    this.conceptCache.set(conceptId, concept);
+    return concept;
   }
 
   getIndexEntry(conceptId: string): ConceptSummary | undefined {
     return this.summaryMap.get(conceptId);
   }
 
-  getConcepts(): ConceptSummary[] {
+  getConcepts(): (ConceptSummary | undefined)[] {
     return this.index?.concepts ?? [];
   }
 
@@ -188,16 +240,14 @@ export class DatasetAdapter {
   }
 
   getAdjacentConcepts(conceptId: string): { prev: string | null; next: string | null } {
-    const concepts = this.index?.concepts as (ConceptSummary | undefined)[] | undefined;
+    const concepts = this.index?.concepts;
     if (!concepts) return { prev: null, next: null };
     const idx = this.getConceptPosition(conceptId);
     if (idx === -1) return { prev: null, next: null };
-    // Scan backward for prev (skip undefined)
     let prev: string | null = null;
     for (let i = idx - 1; i >= 0; i--) {
       if (concepts[i]) { prev = concepts[i]!.id; break; }
     }
-    // Scan forward for next (skip undefined)
     let next: string | null = null;
     for (let i = idx + 1; i < concepts.length; i++) {
       if (concepts[i]) { next = concepts[i]!.id; break; }
@@ -205,53 +255,92 @@ export class DatasetAdapter {
     return { prev, next };
   }
 
-  search(query: string, lang: string = 'eng'): SearchHit[] {
+  search(query: string): SearchHit[] {
     const q = query.toLowerCase();
-    const hits: SearchHit[] = [];
-    const arr = this.index?.concepts as (ConceptSummary | undefined)[] | undefined;
-    if (!arr) return hits;
+    const arr = this.index?.concepts;
+    if (!arr) return [];
+
+    type ScoredHit = SearchHit & { _score: number };
+    const scored: ScoredHit[] = [];
 
     for (const entry of arr) {
       if (!entry) continue;
-      const term = entry.eng || '';
-      const termMatch = term.toLowerCase().includes(q);
-      const idMatch = entry.id.toLowerCase().includes(q);
-      if (termMatch || idMatch) {
-        const matchField = termMatch ? 'designation' as const : 'id' as const;
-        let snippet: string | undefined;
-        if (!termMatch && idMatch) {
-          snippet = `ID: ${entry.id}`;
-        }
-        hits.push({
+
+      // ID search — exact match highest, then starts with, then contains
+      const idLow = entry.id.toLowerCase();
+      if (idLow.includes(q)) {
+        const score = idLow === q ? 4 : idLow.startsWith(q) ? 3 : 2;
+        scored.push({
           conceptId: entry.id,
           registerId: this.registerId,
-          designation: term,
-          language: lang,
-          matchField,
-          snippet,
+          designation: entry.eng || '',
+          language: '',
+          matchField: 'id',
+          snippet: `ID: ${entry.id}`,
+          _score: score,
         });
+        continue;
+      }
+
+      // Multi-language designation search
+      for (const [language, term] of Object.entries(entry.designations)) {
+        if (!term) continue;
+        const tLow = term.toLowerCase();
+        if (tLow.includes(q)) {
+          const score = tLow === q ? 4 : tLow.startsWith(q) ? 3 : 1;
+          scored.push({
+            conceptId: entry.id,
+            registerId: this.registerId,
+            designation: term,
+            language,
+            matchField: 'designation',
+            _score: score,
+          });
+        }
       }
     }
-    return hits;
+
+    // Sort by score descending, then alphabetically
+    scored.sort((a, b) => b._score - a._score || a.designation.localeCompare(b.designation));
+    return scored;
   }
 
-  extractEdges(concept: ConceptDocument): GraphEdge[] {
+  extractEdges(concept: Concept): GraphEdge[] {
     const edges: GraphEdge[] = [];
-    const sourceUri = concept['@id'];
-
-    for (const [_lang, lc] of Object.entries(concept['gl:localizedConcept'] || {})) {
-      if (lc['gl:references']) {
-        for (const ref of lc['gl:references']) {
-          if (ref['@id'] && ref['@id'] !== sourceUri) {
-            const parsed = UriRouter.parseUri(ref['@id']);
-            edges.push({
-              source: sourceUri,
-              target: ref['@id'],
-              type: 'references',
-              label: ref['gl:term'],
-              register: parsed?.registerId ?? this.registerId,
-            });
-          }
+    const uriBase = this.manifest?.uriBase || 'https://glossarist.org';
+    const sourceUri = concept.uri || `${uriBase}/${this.registerId}/concept/${concept.id}`;
+
+    // Managed concept level relationships
+    for (const rc of concept.relatedConcepts) {
+      const target = resolveRefTarget(rc, uriBase, this.registerId);
+      if (target && target !== sourceUri) {
+        const parsed = UriRouter.parseUri(target);
+        edges.push({
+          source: sourceUri,
+          target,
+          type: rc.type || 'references',
+          label: rc.content || undefined,
+          register: parsed?.registerId ?? this.registerId,
+        });
+      }
+    }
+
+    // Per-localization references (from inline extraction in generate-data)
+    for (const lang of concept.languages) {
+      const lc = concept.localization(lang);
+      if (!lc) continue;
+      for (const rc of lc.related) {
+        const target = resolveRefTarget(rc, uriBase, this.registerId);
+        if (target && target !== sourceUri) {
+          const parsed = UriRouter.parseUri(target);
+          edges.push({
+            source: sourceUri,
+            target,
+            type: rc.type || 'references',
+            label: rc.content || undefined,
+            register: parsed?.registerId ?? this.registerId,
+            lang,
+          });
         }
       }
     }
@@ -259,6 +348,42 @@ export class DatasetAdapter {
     return edges;
   }
 
+  extractDomainEdges(concept: Concept): GraphEdge[] {
+    const edges: GraphEdge[] = [];
+    const uriBase = this.manifest?.uriBase || 'https://glossarist.org';
+    const sourceUri = concept.uri || `${uriBase}/${this.registerId}/concept/${concept.id}`;
+
+    for (const lang of concept.languages) {
+      const lc = concept.localization(lang);
+      if (lc?.domain) {
+        edges.push({
+          source: sourceUri,
+          target: `${uriBase}/${this.registerId}/domain/${slugify(lc.domain)}`,
+          type: 'domain',
+          label: lc.domain,
+          register: this.registerId,
+          lang,
+        });
+      }
+    }
+    return edges;
+  }
+
+  async loadDomainNodes(): Promise<GraphNode[]> {
+    const resp = await fetch(`${this.baseUrl}/domain-nodes.json`);
+    if (!resp.ok) return [];
+    const data = await resp.json();
+    return (data.domainNodes || []).map((dn: any) => ({
+      uri: dn.uri,
+      register: dn.registerId,
+      conceptId: dn.uri.split('/domain/')[1] || '',
+      designations: { eng: dn.label },
+      status: 'domain',
+      loaded: true,
+      nodeType: 'domain' as const,
+    }));
+  }
+
   async loadEdgeIndex(): Promise<GraphEdge[]> {
     const resp = await fetch(`${this.baseUrl}/edges.json`);
     if (!resp.ok) return [];