@glossarist/concept-browser 0.3.7 → 0.4.0

package/src/__tests__/concept-timeline.test.ts

@@ -1,23 +1,30 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { mount, flushPromises } from '@vue/test-utils';
-import { createPinia, setActivePinia } from 'pinia';
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
 import ConceptTimeline from '../components/ConceptTimeline.vue';
-import type { LocalizedConcept } from '../adapters/types';
+import { conceptFromJson } from '../adapters/model-bridge';
 
-function makeLocalizedConcept(overrides: Partial<LocalizedConcept> = {}): LocalizedConcept {
+function makeConceptJson(overrides: Record<string, any> = {}) {
   return {
-    '@id': 'https://glossarist.org/test/concept/1/eng',
-    '@type': 'gl:LocalizedConcept',
-    'gl:languageCode': 'eng',
-    'gl:entryStatus': 'valid',
-    ...overrides,
+    '@id': 'https://glossarist.org/test/concept/1',
+    '@type': 'gl:Concept',
+    'gl:identifier': '1',
+    'gl:localizedConcept': {
+      eng: {
+        '@type': 'gl:LocalizedConcept',
+        'gl:languageCode': 'eng',
+        'gl:entryStatus': 'valid',
+        ...overrides.eng,
+      },
+      ...(overrides.otherLangs || {}),
+    },
   };
 }
 
-function mountTimeline(lcs: Record<string, LocalizedConcept>, activeLang = 'eng', languageOrder?: string[]) {
+function mountTimeline(conceptJson: Record<string, any>, activeLang = 'eng', languageOrder?: string[]) {
+  const concept = conceptFromJson(conceptJson);
   return mount(ConceptTimeline, {
     props: {
-      localizedConcepts: lcs,
+      concept,
       activeLang,
       languageOrder,
     },
@@ -25,40 +32,43 @@ function mountTimeline(lcs: Record<string, LocalizedConcept>, activeLang = 'eng'
 }
 
 describe('ConceptTimeline', () => {
-  it('shows empty state when no history data', () => {
-    const lc = makeLocalizedConcept({ 'gl:entryStatus': undefined });
-    const wrapper = mountTimeline({ eng: lc });
-    expect(wrapper.text()).toContain('No history data available');
+  it('shows review metadata even without history entries', () => {
+    const wrapper = mountTimeline(makeConceptJson());
+    expect(wrapper.text()).toContain('Review Details');
+    expect(wrapper.text()).toContain('valid');
   });
 
   it('renders review date as timeline entry', () => {
-    const lc = makeLocalizedConcept({
-      'gl:reviewDate': '2023-05-15',
+    const json = makeConceptJson({
+      eng: { 'gl:reviewDate': '2023-05-15' },
     });
-    const wrapper = mountTimeline({ eng: lc });
+    const wrapper = mountTimeline(json);
     expect(wrapper.text()).toContain('Review initiated');
     expect(wrapper.text()).toContain('2023');
   });
 
   it('renders review decision event', () => {
-    const lc = makeLocalizedConcept({
-      'gl:reviewDecisionEvent': 'Accepted',
-      'gl:reviewDate': '2023-05-15',
-      'gl:reviewDecisionDate': '2023-06-01',
+    const json = makeConceptJson({
+      eng: {
+        'gl:reviewDecisionEvent': 'Accepted',
+        'gl:reviewDate': '2023-05-15',
+        'gl:reviewDecisionDate': '2023-06-01',
+      },
     });
-    const wrapper = mountTimeline({ eng: lc });
-    // The review event banner
+    const wrapper = mountTimeline(json);
     expect(wrapper.text()).toContain('Accepted');
   });
 
   it('renders gl:dates entries', () => {
-    const lc = makeLocalizedConcept({
-      'gl:dates': [
-        { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
-        { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
-      ],
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
+          { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
+        ],
+      },
     });
-    const wrapper = mountTimeline({ eng: lc });
+    const wrapper = mountTimeline(json);
     expect(wrapper.text()).toContain('Concept accepted');
     expect(wrapper.text()).toContain('Definition amended');
     expect(wrapper.text()).toContain('2020');
@@ -66,48 +76,58 @@ describe('ConceptTimeline', () => {
   });
 
   it('sorts entries by date ascending', () => {
-    const lc = makeLocalizedConcept({
-      'gl:dates': [
-        { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
-        { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
-      ],
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
+          { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
+        ],
+      },
     });
-    const wrapper = mountTimeline({ eng: lc });
+    const wrapper = mountTimeline(json);
     const texts = wrapper.text();
-    // "accepted" entry should appear before "amended" in the rendered output
     const acceptedIdx = texts.indexOf('Concept accepted');
     const amendedIdx = texts.indexOf('Definition amended');
     expect(acceptedIdx).toBeLessThan(amendedIdx);
   });
 
   it('shows language selector when multiple languages have history', () => {
-    const eng = makeLocalizedConcept({ 'gl:reviewDate': '2023-01-01' });
-    const fra = makeLocalizedConcept({
-      '@id': 'https://glossarist.org/test/concept/1/fra',
-      'gl:languageCode': 'fra',
-      'gl:reviewDate': '2023-02-01',
+    const json = makeConceptJson({
+      eng: { 'gl:reviewDate': '2023-01-01' },
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:reviewDate': '2023-02-01',
+        },
+      },
     });
-    const wrapper = mountTimeline({ eng, fra }, 'eng', ['eng', 'fra']);
+    const wrapper = mountTimeline(json, 'eng', ['eng', 'fra']);
     expect(wrapper.text()).toContain('French');
   });
 
   it('does not show language selector for single-language history', () => {
-    const eng = makeLocalizedConcept({ 'gl:reviewDate': '2023-01-01' });
-    const wrapper = mountTimeline({ eng });
-    // Should not have multiple language buttons
+    const json = makeConceptJson({
+      eng: { 'gl:reviewDate': '2023-01-01' },
+    });
+    const wrapper = mountTimeline(json);
     const buttons = wrapper.findAll('button');
     const langButtons = buttons.filter(b => b.text().includes('French'));
     expect(langButtons.length).toBe(0);
   });
 
   it('emits update:activeLang on language button click', async () => {
-    const eng = makeLocalizedConcept({ 'gl:reviewDate': '2023-01-01' });
-    const fra = makeLocalizedConcept({
-      '@id': 'https://glossarist.org/test/concept/1/fra',
-      'gl:languageCode': 'fra',
-      'gl:reviewDate': '2023-02-01',
+    const json = makeConceptJson({
+      eng: { 'gl:reviewDate': '2023-01-01' },
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:reviewDate': '2023-02-01',
+        },
+      },
     });
-    const wrapper = mountTimeline({ eng, fra }, 'eng', ['eng', 'fra']);
+    const wrapper = mountTimeline(json, 'eng', ['eng', 'fra']);
     const fraBtn = wrapper.findAll('button').find(b => b.text().includes('French'));
     expect(fraBtn).toBeDefined();
     await fraBtn!.trigger('click');
@@ -115,14 +135,16 @@ describe('ConceptTimeline', () => {
   });
 
   it('shows review metadata when present', () => {
-    const lc = makeLocalizedConcept({
-      'gl:reviewDate': '2023-01-01',
-      'gl:reviewStatus': 'final',
-      'gl:reviewDecision': 'accepted',
-      'gl:entryStatus': 'valid',
-      'gl:release': 3,
+    const json = makeConceptJson({
+      eng: {
+        'gl:reviewDate': '2023-01-01',
+        'gl:reviewStatus': 'final',
+        'gl:reviewDecision': 'accepted',
+        'gl:entryStatus': 'valid',
+        'gl:release': '3',
+      },
     });
-    const wrapper = mountTimeline({ eng: lc });
+    const wrapper = mountTimeline(json);
     expect(wrapper.text()).toContain('Review Details');
     expect(wrapper.text()).toContain('final');
     expect(wrapper.text()).toContain('accepted');
@@ -131,16 +153,17 @@ describe('ConceptTimeline', () => {
   });
 
   it('groups by year when more than 3 entries', () => {
-    const lc = makeLocalizedConcept({
-      'gl:dates': [
-        { 'gl:dateType': 'accepted', 'gl:date': '2019-03-01' },
-        { 'gl:dateType': 'amended', 'gl:date': '2020-06-15' },
-        { 'gl:dateType': 'amended', 'gl:date': '2021-09-20' },
-        { 'gl:dateType': 'published', 'gl:date': '2023-01-10' },
-      ],
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'accepted', 'gl:date': '2019-03-01' },
+          { 'gl:dateType': 'amended', 'gl:date': '2020-06-15' },
+          { 'gl:dateType': 'amended', 'gl:date': '2021-09-20' },
+          { 'gl:dateType': 'published', 'gl:date': '2023-01-10' },
+        ],
+      },
     });
-    const wrapper = mountTimeline({ eng: lc });
-    // Year markers should be rendered
+    const wrapper = mountTimeline(json);
     expect(wrapper.text()).toContain('2019');
     expect(wrapper.text()).toContain('2020');
     expect(wrapper.text()).toContain('2021');
@@ -148,27 +171,29 @@ describe('ConceptTimeline', () => {
   });
 
   it('uses simple layout for 3 or fewer entries', () => {
-    const lc = makeLocalizedConcept({
-      'gl:dates': [
-        { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
-        { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
-      ],
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
+          { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
+        ],
+      },
     });
-    const wrapper = mountTimeline({ eng: lc });
-    // Should have entries but no year grouping markers
+    const wrapper = mountTimeline(json);
     expect(wrapper.text()).toContain('Concept accepted');
     expect(wrapper.text()).toContain('Definition amended');
   });
 
   it('deduplicates review date if it matches a gl:date entry', () => {
-    const lc = makeLocalizedConcept({
-      'gl:dates': [
-        { 'gl:dateType': 'review', 'gl:date': '2023-05-15' },
-      ],
-      'gl:reviewDate': '2023-05-15',
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'review', 'gl:date': '2023-05-15' },
+        ],
+        'gl:reviewDate': '2023-05-15',
+      },
     });
-    const wrapper = mountTimeline({ eng: lc });
-    // Should only have one entry for that date, not two "review" entries
+    const wrapper = mountTimeline(json);
     const reviewCount = wrapper.text().split('Review initiated').length - 1;
     expect(reviewCount).toBeLessThanOrEqual(1);
   });

package/src/__tests__/concept-view.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach } from 'vitest';
 import { mount, flushPromises } from '@vue/test-utils';
 import ConceptView from '../views/ConceptView.vue';
 import { useVocabularyStore } from '../stores/vocabulary';
+import { conceptFromJson } from '../adapters/model-bridge';
 import { createTestRouter, setupPinia, makeManifest, makeAdapterStub } from './test-helpers';
 
 describe('ConceptView', () => {
@@ -52,10 +53,22 @@ describe('ConceptView', () => {
   });
 
   it('renders ConceptDetail when concept loads', async () => {
-    const concept = {
+    const concept = conceptFromJson({
       '@id': 'https://glossarist.org/test/concept/1',
       '@type': 'gl:Concept',
-    };
+      'gl:identifier': '1',
+      'gl:localizedConcept': {
+        eng: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'eng',
+          'gl:entryStatus': 'valid',
+          'gl:designation': [
+            { '@type': 'gl:Expression', 'gl:term': 'test', 'gl:normativeStatus': 'preferred' },
+          ],
+          'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'A test concept.' }],
+        },
+      },
+    });
     const store = useVocabularyStore();
     store.datasets.set('test', makeAdapterStub({ fetchConcept: () => Promise.resolve(concept) }));
 

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

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { DatasetAdapter } from '../adapters/DatasetAdapter';
+import { conceptFromJson } from '../adapters/model-bridge';
 
 // Mock fetch globally
 const mockFetch = vi.fn();
@@ -98,13 +99,13 @@ describe('DatasetAdapter', () => {
       mockFetch.mockReturnValue(mockJsonResponse(concept));
 
       const result = await adapter.fetchConcept('103-01-02');
-      expect(result['gl:identifier']).toBe('103-01-02');
+      expect(result.id).toBe('103-01-02');
       expect(mockFetch).toHaveBeenCalledWith('/data/test/concepts/103-01-02.json');
 
       // Second call should use cache
       mockFetch.mockReset();
       const cached = await adapter.fetchConcept('103-01-02');
-      expect(cached['gl:identifier']).toBe('103-01-02');
+      expect(cached.id).toBe('103-01-02');
       expect(mockFetch).not.toHaveBeenCalled();
     });
 
@@ -195,12 +196,56 @@ describe('DatasetAdapter', () => {
       const hits = adapter.search('xyznotfound');
       expect(hits.length).toBe(0);
     });
+
+    it('ranks exact matches above starts-with above contains', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 3,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '1', designations: { eng: 'mass' }, eng: 'mass', status: 'valid' },
+          { id: '2', designations: { eng: 'mass flow rate' }, eng: 'mass flow rate', status: 'valid' },
+          { id: '3', designations: { eng: 'center of mass' }, eng: 'center of mass', status: 'valid' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const hits = adapter.search('mass');
+      // Exact match first, then starts-with, then contains
+      expect(hits[0].conceptId).toBe('1');
+      expect(hits[1].conceptId).toBe('2');
+      expect(hits[2].conceptId).toBe('3');
+    });
+
+    it('ranks ID exact match highest', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 2,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '102-01-01', designations: { eng: 'field' }, eng: 'field', status: 'valid' },
+          { id: '102-01-02', designations: { eng: 'electromagnetic field' }, eng: 'electromagnetic field', status: 'valid' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const hits = adapter.search('102-01-01');
+      expect(hits[0].conceptId).toBe('102-01-01');
+      expect(hits[0].matchField).toBe('id');
+    });
   });
 
   describe('extractEdges', () => {
     it('extracts cross-reference edges from gl:references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -209,18 +254,38 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(2);
       expect(edges[0].target).toBe('https://glossarist.org/iev/concept/103-01-02');
       expect(edges[0].type).toBe('references');
       expect(edges[0].label).toBe('functional');
     });
 
+    it('tags reference edges with language', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {
+          eng: { 'gl:references': [
+            { '@id': 'https://glossarist.org/test/concept/2', 'gl:term': 'other' },
+          ]},
+          fra: { 'gl:references': [
+            { '@id': 'https://glossarist.org/test/concept/3', 'gl:term': 'autre' },
+          ]},
+        },
+      });
+      const edges = adapter.extractEdges(concept);
+      expect(edges.length).toBe(2);
+      expect(edges.find(e => e.lang === 'eng')?.target).toContain('/concept/2');
+      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/concept/3');
+    });
+
     it('skips self-references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -228,37 +293,40 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(0);
     });
 
     it('handles concepts with no references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {},
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(0);
     });
 
     it('handles empty localizedConcept', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {},
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(0);
     });
 
     it('collects references from multiple languages without duplication', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -271,16 +339,17 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
       // Same target from two languages — both edges are kept (different labels)
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(2);
     });
 
     it('extracts inline IEV cross-references from gl:references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/112-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -289,9 +358,9 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(2);
       expect(edges[0].target).toBe('https://glossarist.org/iev/concept/102-02-18');
       expect(edges[0].label).toBe('scalar');
@@ -300,8 +369,9 @@ describe('DatasetAdapter', () => {
     });
 
     it('extracts inline URN cross-references from gl:references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/3.1.1.1',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -309,15 +379,94 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(1);
       expect(edges[0].target).toBe('https://glossarist.org/isotc204/concept/3.1.1.6');
       expect(edges[0].label).toBe('entity');
     });
   });
 
+  describe('extractDomainEdges', () => {
+    it('extracts domain edges from gl:domain field per language', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/3',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {
+          eng: { 'gl:domain': 'geometry' },
+          fra: { 'gl:domain': 'géométrie' },
+        },
+      });
+      const edges = adapter.extractDomainEdges(concept);
+      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 === 'eng')?.label).toBe('geometry');
+      expect(edges.find(e => e.lang === 'fra')?.label).toBe('géométrie');
+    });
+
+    it('handles same domain across languages', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {
+          eng: { 'gl:domain': 'metadata' },
+          fra: { 'gl:domain': 'metadata' },
+        },
+      });
+      const edges = adapter.extractDomainEdges(concept);
+      expect(edges.length).toBe(2);
+      expect(edges[0].target).toBe(edges[1].target);
+      expect(edges[0].target).toContain('/domain/metadata');
+    });
+
+    it('skips concepts without gl:domain', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': { eng: {} },
+      });
+      const edges = adapter.extractDomainEdges(concept);
+      expect(edges.length).toBe(0);
+    });
+
+    it('handles empty localizedConcept', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {},
+      });
+      const edges = adapter.extractDomainEdges(concept);
+      expect(edges.length).toBe(0);
+    });
+  });
+
+  describe('loadDomainNodes', () => {
+    it('loads domain nodes from domain-nodes.json', async () => {
+      mockFetch.mockReturnValue(mockJsonResponse({
+        registerId: 'test',
+        domainNodes: [
+          { uri: 'https://glossarist.org/test/domain/iso-19107', label: 'ISO 19107', registerId: 'test', conceptCount: 147 },
+        ],
+      }));
+      const nodes = await adapter.loadDomainNodes();
+      expect(nodes.length).toBe(1);
+      expect(nodes[0].nodeType).toBe('domain');
+      expect(nodes[0].status).toBe('domain');
+      expect(nodes[0].loaded).toBe(true);
+      expect(nodes[0].designations.eng).toBe('ISO 19107');
+      expect(mockFetch).toHaveBeenCalledWith('/data/test/domain-nodes.json');
+    });
+
+    it('returns empty array on fetch failure', async () => {
+      mockFetch.mockReturnValue(Promise.resolve({ ok: false, status: 404 } as Response));
+      const nodes = await adapter.loadDomainNodes();
+      expect(nodes).toEqual([]);
+    });
+  });
+
   describe('getLanguages', () => {
     it('returns languages from manifest', async () => {
       const manifest = {

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

@@ -34,6 +34,7 @@ function makeManifest(overrides: Partial<Manifest> = {}): Manifest {
 function makeConcepts(count: number): ConceptSummary[] {
   return Array.from({ length: count }, (_, i) => ({
     id: String(i + 1),
+    designations: { eng: `term ${i + 1}` },
     eng: `term ${i + 1}`,
     status: i % 10 === 0 ? 'superseded' : 'valid',
   }));
@@ -147,9 +148,9 @@ describe('DatasetView', () => {
 
   it('filters concepts by term', async () => {
     const concepts: ConceptSummary[] = [
-      { id: '1', eng: 'road network', status: 'valid' },
-      { id: '2', eng: 'bridge design', status: 'valid' },
-      { id: '3', eng: 'road user', status: 'valid' },
+      { id: '1', designations: { eng: 'road network' }, eng: 'road network', status: 'valid' },
+      { id: '2', designations: { eng: 'bridge design' }, eng: 'bridge design', status: 'valid' },
+      { id: '3', designations: { eng: 'road user' }, eng: 'road user', status: 'valid' },
     ];
     const wrapper = mountDataset(concepts);
     await flushPromises();
@@ -163,8 +164,8 @@ describe('DatasetView', () => {
 
   it('filters concepts by ID', async () => {
     const concepts: ConceptSummary[] = [
-      { id: '3.1.1.1', eng: 'term one', status: 'valid' },
-      { id: '3.1.1.2', eng: 'term two', status: 'valid' },
+      { id: '3.1.1.1', designations: { eng: 'term one' }, eng: 'term one', status: 'valid' },
+      { id: '3.1.1.2', designations: { eng: 'term two' }, eng: 'term two', status: 'valid' },
     ];
     const wrapper = mountDataset(concepts);
     await flushPromises();