@glossarist/concept-browser 0.3.4 → 0.4.0

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

@@ -0,0 +1,161 @@
+import { describe, it, expect } from 'vitest';
+import { Expression, Abbreviation } from 'glossarist';
+import {
+  designationTypeInfo,
+  normativeStatusInfo,
+  abbreviationDetails,
+  grammarBadges,
+  pronunciationLabel,
+  pronunciationTooltip,
+  termTypeInfo,
+  sourceStatusInfo,
+  sourceTypeInfo,
+} from '../utils/designation-registry';
+
+describe('designationTypeInfo', () => {
+  it('returns info for expression', () => {
+    const d = Expression.fromJSON({ type: 'expression', designation: 'test' });
+    const info = designationTypeInfo(d);
+    expect(info.label).toBe('expression');
+    expect(info.color).toContain('sky');
+  });
+
+  it('returns info for abbreviation', () => {
+    const d = Abbreviation.fromJSON({ type: 'abbreviation', designation: 'ISO' });
+    const info = designationTypeInfo(d);
+    expect(info.label).toBe('abbreviation');
+    expect(info.color).toContain('amber');
+  });
+
+  it('returns info for symbol with broader hierarchy', () => {
+    const d = { type: 'letter_symbol', designation: 'x' } as any;
+    const info = designationTypeInfo(d);
+    expect(info.label).toBe('letter symbol');
+  });
+
+  it('returns fallback for unknown type', () => {
+    const d = { type: 'custom', designation: 'x' } as any;
+    const info = designationTypeInfo(d);
+    expect(info.label).toBe('custom');
+  });
+});
+
+describe('normativeStatusInfo', () => {
+  it('returns preferred', () => {
+    const info = normativeStatusInfo('preferred');
+    expect(info.label).toBe('preferred');
+    expect(info.color).toContain('emerald');
+  });
+
+  it('returns deprecated', () => {
+    const info = normativeStatusInfo('deprecated');
+    expect(info.label).toBe('deprecated');
+    expect(info.color).toContain('red');
+  });
+
+  it('returns empty for null', () => {
+    const info = normativeStatusInfo(null);
+    expect(info.label).toBe('');
+  });
+});
+
+describe('sourceStatusInfo', () => {
+  it('returns identical status', () => {
+    const info = sourceStatusInfo('identical');
+    expect(info.label).toBe('identical');
+  });
+
+  it('returns modified status', () => {
+    const info = sourceStatusInfo('modified');
+    expect(info.label).toBe('modified');
+    expect(info.definition).toBeTruthy();
+  });
+
+  it('returns empty for null', () => {
+    const info = sourceStatusInfo(null);
+    expect(info.label).toBe('');
+  });
+});
+
+describe('sourceTypeInfo', () => {
+  it('returns authoritative', () => {
+    const info = sourceTypeInfo('authoritative');
+    expect(info.label).toBe('authoritative');
+    expect(info.color).toContain('purple');
+  });
+
+  it('returns lineage', () => {
+    const info = sourceTypeInfo('lineage');
+    expect(info.label).toBe('lineage');
+    expect(info.color).toContain('blue');
+  });
+});
+
+describe('termTypeInfo', () => {
+  it('returns term type with definition', () => {
+    const info = termTypeInfo('acronym');
+    expect(info.label).toBe('acronym');
+    expect(info.definition).toBeTruthy();
+    expect(info.category).toBe('abbreviation');
+  });
+
+  it('returns empty for null', () => {
+    const info = termTypeInfo(null);
+    expect(info.label).toBe('');
+  });
+});
+
+describe('abbreviationDetails', () => {
+  it('identifies acronym', () => {
+    const d = Abbreviation.fromJSON({ type: 'abbreviation', designation: 'ISO', acronym: true });
+    expect(abbreviationDetails(d)).toContain('acronym');
+    expect(abbreviationDetails(d)).not.toContain('initialism');
+  });
+
+  it('identifies initialism', () => {
+    const d = Abbreviation.fromJSON({ type: 'abbreviation', designation: 'UN', initialism: true });
+    expect(abbreviationDetails(d)).toContain('initialism');
+  });
+
+  it('identifies truncation', () => {
+    const d = Abbreviation.fromJSON({ type: 'abbreviation', designation: 'info', truncation: true });
+    expect(abbreviationDetails(d)).toContain('truncation');
+  });
+});
+
+describe('grammarBadges', () => {
+  it('returns gender badge with ontology label', () => {
+    const d = Expression.fromJSON({ type: 'expression', designation: 'test', grammar_info: [{ gender: 'f' }] });
+    const badges = grammarBadges((d as any).grammarInfo[0]);
+    expect(badges).toEqual([{ label: 'feminine', definition: 'Feminine grammatical gender.' }]);
+  });
+
+  it('returns gender and number badges', () => {
+    const d = Expression.fromJSON({ type: 'expression', designation: 'test', grammar_info: [{ gender: 'm', number: 'singular' }] });
+    const badges = grammarBadges((d as any).grammarInfo[0]);
+    expect(badges[0].label).toBe('masculine');
+    expect(badges[1].label).toBe('singular');
+  });
+});
+
+describe('pronunciationLabel', () => {
+  it('shows content with system', () => {
+    const p = { content: '/tɛst/', system: 'IPA', language: null, script: null, country: null } as any;
+    expect(pronunciationLabel(p)).toBe('/tɛst/ (IPA)');
+  });
+
+  it('shows content only', () => {
+    const p = { content: '/t/', system: null, language: null, script: null, country: null } as any;
+    expect(pronunciationLabel(p)).toBe('/t/');
+  });
+});
+
+describe('pronunciationTooltip', () => {
+  it('includes all metadata', () => {
+    const p = { content: '/t/', system: 'IPA', language: 'en', script: 'Latn', country: 'US' } as any;
+    const tip = pronunciationTooltip(p);
+    expect(tip).toContain('Language: en');
+    expect(tip).toContain('System: IPA');
+    expect(tip).toContain('Country: US');
+  });
+});

package/src/__tests__/format-downloads.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import FormatDownloads from '../components/FormatDownloads.vue';
+
+async function createTestRouter() {
+  return createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+    ],
+  });
+}
+
+describe('FormatDownloads', () => {
+  it('renders download links for known formats', async () => {
+    const pinia = createPinia();
+    setActivePinia(pinia);
+    const router = await createTestRouter();
+    const wrapper = mount(FormatDownloads, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test', conceptId: '3.1.1.1', formats: ['ttl', 'jsonld'] },
+    });
+    expect(wrapper.text()).toContain('Downloads');
+    expect(wrapper.text()).toContain('Turtle RDF');
+    expect(wrapper.text()).toContain('JSON-LD');
+  });
+
+  it('generates correct URLs', async () => {
+    const pinia = createPinia();
+    setActivePinia(pinia);
+    const router = await createTestRouter();
+    const wrapper = mount(FormatDownloads, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test', conceptId: '3.1.1.1', formats: ['ttl'] },
+    });
+    const link = wrapper.find('a');
+    expect(link.attributes('href')).toBe('/data/test/concepts/3.1.1.1.ttl');
+  });
+
+  it('filters unknown formats', async () => {
+    const pinia = createPinia();
+    setActivePinia(pinia);
+    const router = await createTestRouter();
+    const wrapper = mount(FormatDownloads, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test', conceptId: '1', formats: ['ttl', 'unknown'] },
+    });
+    const links = wrapper.findAll('a');
+    expect(links.length).toBe(1);
+  });
+
+  it('renders nothing when all formats are unknown', async () => {
+    const pinia = createPinia();
+    setActivePinia(pinia);
+    const router = await createTestRouter();
+    const wrapper = mount(FormatDownloads, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test', conceptId: '1', formats: ['unknown'] },
+    });
+    expect(wrapper.find('a').exists()).toBe(false);
+  });
+
+  it('renders nothing when formats array is empty', async () => {
+    const pinia = createPinia();
+    setActivePinia(pinia);
+    const router = await createTestRouter();
+    const wrapper = mount(FormatDownloads, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test', conceptId: '1', formats: [] },
+    });
+    expect(wrapper.find('a').exists()).toBe(false);
+  });
+
+  it('sets download attribute on links', async () => {
+    const pinia = createPinia();
+    setActivePinia(pinia);
+    const router = await createTestRouter();
+    const wrapper = mount(FormatDownloads, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test', conceptId: '3.1.1.1', formats: ['jsonld'] },
+    });
+    const link = wrapper.find('a');
+    expect(link.attributes('download')).toBe('3.1.1.1.jsonld');
+  });
+
+  it('shows TBX-XML format', async () => {
+    const pinia = createPinia();
+    setActivePinia(pinia);
+    const router = await createTestRouter();
+    const wrapper = mount(FormatDownloads, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test', conceptId: '1', formats: ['tbx'] },
+    });
+    expect(wrapper.text()).toContain('TBX-XML');
+  });
+});

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

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount, flushPromises } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import GraphView from '../views/GraphView.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+
+async function createTestRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/graph', name: 'graph', component: { template: '<div/>' } },
+    ],
+  });
+  router.push('/graph');
+  await router.isReady();
+  return router;
+}
+
+describe('GraphView', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+  });
+
+  function mountGraph() {
+    return mount(GraphView, {
+      global: {
+        plugins: [pinia, router],
+        stubs: { GraphPanel: true },
+      },
+    });
+  }
+
+  it('renders breadcrumb navigation', () => {
+    const wrapper = mountGraph();
+    expect(wrapper.text()).toContain('Home');
+    expect(wrapper.text()).toContain('Graph View');
+  });
+
+  it('shows loading spinner initially', () => {
+    const wrapper = mountGraph();
+    expect(wrapper.find('.animate-spin').exists()).toBe(true);
+    expect(wrapper.text()).toContain('Loading graph data');
+  });
+
+  it('renders GraphPanel after loading', async () => {
+    const wrapper = mountGraph();
+    await flushPromises();
+    expect(wrapper.findComponent({ name: 'GraphPanel' }).exists()).toBe(true);
+  });
+
+  it('shows edge count after loading', async () => {
+    const wrapper = mountGraph();
+    await flushPromises();
+    expect(wrapper.text()).toContain('edges');
+  });
+
+  it('has full-height container', () => {
+    const wrapper = mountGraph();
+    const container = wrapper.find('.flex.flex-col');
+    expect(container.exists()).toBe(true);
+  });
+});

package/src/__tests__/graph.test.ts

@@ -91,6 +91,37 @@ describe('GraphEngine', () => {
       expect(g.edgeCount).toBe(1);
     });
 
+    it('keeps separate edges for different languages', () => {
+      const g = new GraphEngine();
+      g.addEdge({ source: 'uri:a', target: 'uri:b', type: 'references', register: 'test', lang: 'eng' });
+      g.addEdge({ source: 'uri:a', target: 'uri:b', type: 'references', register: 'test', lang: 'fra' });
+      expect(g.edgeCount).toBe(2);
+    });
+
+    it('deduplicates edges with same source+target+type+lang', () => {
+      const g = new GraphEngine();
+      g.addEdge({ source: 'uri:a', target: 'uri:b', type: 'references', register: 'test', lang: 'eng' });
+      g.addEdge({ source: 'uri:a', target: 'uri:b', type: 'references', register: 'test', lang: 'eng' });
+      expect(g.edgeCount).toBe(1);
+    });
+
+    it('creates domain stub with correct fields', () => {
+      const g = new GraphEngine();
+      g.addEdge({
+        source: 'https://glossarist.org/isotc211/concept/3',
+        target: 'https://glossarist.org/isotc211/domain/iso-19105',
+        type: 'domain',
+        label: 'ISO 19105',
+        register: 'isotc211',
+        lang: 'eng',
+      });
+      const domainNode = g.getNode('https://glossarist.org/isotc211/domain/iso-19105');
+      expect(domainNode?.register).toBe('isotc211');
+      expect(domainNode?.nodeType).toBe('domain');
+      expect(domainNode?.status).toBe('domain');
+      expect(domainNode?.loaded).toBe(false);
+    });
+
     it('extracts register from URI for stub nodes', () => {
       const g = new GraphEngine();
       g.addEdge({
@@ -172,6 +203,37 @@ describe('GraphEngine', () => {
       const sub = g.getSubgraph('uri:a', 5);
       expect(sub.nodes.length).toBe(2);
     });
+
+    it('does not traverse past domain nodes in getSubgraph', () => {
+      const g = new GraphEngine();
+      g.addNode(makeNode('https://glossarist.org/test/concept/a', 'a'));
+      g.addNode(makeNode('https://glossarist.org/test/concept/b', 'b'));
+      g.addNode(makeNode('https://glossarist.org/test/concept/c', 'c'));
+      g.addNode(makeNode('https://glossarist.org/test/concept/d', 'd'));
+
+      g.addEdge({
+        source: 'https://glossarist.org/test/concept/a',
+        target: 'https://glossarist.org/test/domain/iso-12345',
+        type: 'domain', register: 'test', label: 'ISO 12345', lang: 'eng',
+      });
+      g.addEdge({
+        source: 'https://glossarist.org/test/concept/b',
+        target: 'https://glossarist.org/test/domain/iso-12345',
+        type: 'domain', register: 'test', label: 'ISO 12345', lang: 'eng',
+      });
+      g.addEdge({
+        source: 'https://glossarist.org/test/concept/c',
+        target: 'https://glossarist.org/test/domain/iso-12345',
+        type: 'domain', register: 'test', label: 'ISO 12345', lang: 'eng',
+      });
+
+      const sub = g.getSubgraph('https://glossarist.org/test/concept/a', 3);
+      const nodeUris = sub.nodes.map(n => n.uri);
+      expect(nodeUris).toContain('https://glossarist.org/test/concept/a');
+      expect(nodeUris).toContain('https://glossarist.org/test/domain/iso-12345');
+      expect(nodeUris).not.toContain('https://glossarist.org/test/concept/b');
+      expect(nodeUris).not.toContain('https://glossarist.org/test/concept/c');
+    });
   });
 
   describe('getAllNodes', () => {

package/src/__tests__/home-interaction.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount, flushPromises } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import HomeView from '../views/HomeView.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+import type { Manifest } from '../adapters/types';
+
+function makeManifest(overrides: Partial<Manifest> = {}): Manifest {
+  return {
+    id: 'test',
+    datasetUri: 'https://glossarist.org/test/concept',
+    title: 'Test Dataset',
+    description: 'A test dataset',
+    owner: 'ISO',
+    baseUrl: '/data/test',
+    languages: ['eng', 'fra'],
+    conceptCount: 100,
+    conceptUrlTemplate: '/data/test/concepts/{id}.json',
+    indexUrl: '/data/test/index.json',
+    contextUrl: '/data/test/context.json',
+    uriBase: 'https://glossarist.org',
+    status: 'published',
+    schemaVersion: '1.0',
+    tags: [],
+    lastUpdated: '2025-01-01',
+    sourceRepo: 'https://example.com/repo',
+    chunkSize: 1000,
+    color: '#3366ff',
+    ...overrides,
+  };
+}
+
+async function createTestRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId', name: 'dataset', component: { template: '<div/>' } },
+      { path: '/search', name: 'search', component: { template: '<div/>' } },
+      { path: '/graph', name: 'graph', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/concept/:conceptId', name: 'concept', component: { template: '<div/>' } },
+    ],
+  });
+  router.push('/');
+  await router.isReady();
+  return router;
+}
+
+describe('HomeView interactions', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+  });
+
+  function mountHome() {
+    return mount(HomeView, {
+      global: { plugins: [pinia, router] },
+    });
+  }
+
+  it('renders the welcome hero section', () => {
+    const wrapper = mountHome();
+    expect(wrapper.find('h1').text()).toContain('Glossarist');
+  });
+
+  it('renders Search, Graph View, and Surprise Me buttons', () => {
+    const wrapper = mountHome();
+    const buttons = wrapper.findAll('button');
+    const texts = buttons.map(b => b.text());
+    expect(texts.some(t => t.includes('Search'))).toBe(true);
+    expect(texts.some(t => t.includes('Graph View'))).toBe(true);
+    expect(texts.some(t => t.includes('Surprise Me'))).toBe(true);
+  });
+
+  it('navigates to search on Search button click', async () => {
+    const wrapper = mountHome();
+    const searchBtn = wrapper.findAll('button').find(b => b.text().includes('Search'));
+    await searchBtn!.trigger('click');
+    await flushPromises();
+    expect(router.currentRoute.value.name).toBe('search');
+  });
+
+  it('navigates to graph on Graph View button click', async () => {
+    const wrapper = mountHome();
+    const graphBtn = wrapper.findAll('button').find(b => b.text().includes('Graph View'));
+    await graphBtn!.trigger('click');
+    await flushPromises();
+    expect(router.currentRoute.value.name).toBe('graph');
+  });
+
+  it('shows stats counters', () => {
+    const store = useVocabularyStore();
+    store.manifests.set('test', makeManifest());
+    store.datasets.set('test', { index: [], getConceptCount: () => 0 } as any);
+
+    const wrapper = mountHome();
+    expect(wrapper.text()).toContain('Datasets');
+    expect(wrapper.text()).toContain('Concepts');
+    expect(wrapper.text()).toContain('Languages');
+  });
+
+  it('shows a CTA card for a single dataset', () => {
+    const store = useVocabularyStore();
+    store.manifests.set('test', makeManifest());
+    store.datasets.set('test', { index: [], getConceptCount: () => 0 } as any);
+
+    const wrapper = mountHome();
+    expect(wrapper.text()).toContain('Test Dataset');
+    expect(wrapper.text()).toContain('Browse concepts');
+  });
+
+  it('navigates to dataset on CTA click', async () => {
+    const store = useVocabularyStore();
+    store.manifests.set('test', makeManifest());
+    store.datasets.set('test', { index: [], getConceptCount: () => 0 } as any);
+
+    const wrapper = mountHome();
+    const cta = wrapper.findAll('button').find(b => b.text().includes('Browse concepts'));
+    await cta!.trigger('click');
+    await flushPromises();
+    expect(router.currentRoute.value.name).toBe('dataset');
+    expect(router.currentRoute.value.params.registerId).toBe('test');
+  });
+
+  it('shows dataset cards for multiple datasets', () => {
+    const store = useVocabularyStore();
+    store.manifests.set('ds1', makeManifest({ id: 'ds1', title: 'Dataset One' }));
+    store.manifests.set('ds2', makeManifest({ id: 'ds2', title: 'Dataset Two' }));
+    store.datasets.set('ds1', { index: [], getConceptCount: () => 0 } as any);
+    store.datasets.set('ds2', { index: [], getConceptCount: () => 0 } as any);
+
+    const wrapper = mountHome();
+    expect(wrapper.text()).toContain('Dataset One');
+    expect(wrapper.text()).toContain('Dataset Two');
+    expect(wrapper.text()).toContain('Available Datasets');
+  });
+
+  it('navigates to dataset on card click', async () => {
+    const store = useVocabularyStore();
+    store.manifests.set('ds1', makeManifest({ id: 'ds1', title: 'Dataset One' }));
+    store.manifests.set('ds2', makeManifest({ id: 'ds2', title: 'Dataset Two' }));
+    store.datasets.set('ds1', { index: [], getConceptCount: () => 0 } as any);
+    store.datasets.set('ds2', { index: [], getConceptCount: () => 0 } as any);
+
+    const wrapper = mountHome();
+    const card = wrapper.findAll('button').find(b => b.text().includes('Dataset One'));
+    await card!.trigger('click');
+    await flushPromises();
+    expect(router.currentRoute.value.name).toBe('dataset');
+    expect(router.currentRoute.value.params.registerId).toBe('ds1');
+  });
+});