@glossarist/concept-browser 0.7.44 → 0.7.45

package/src/__tests__/model-bridge-entity-refs.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+import { conceptFromJson } from '../adapters/model-bridge';
+import type { Concept } from 'glossarist';
+
+interface ConceptWithEntityRefs {
+  readonly figures: ReadonlyArray<{ entityId: string | null; display: string | null }>;
+  readonly tables: ReadonlyArray<{ entityId: string | null; display: string | null }>;
+  readonly formulas: ReadonlyArray<{ entityId: string | null; display: string | null }>;
+}
+
+function refsOf(c: Concept): ConceptWithEntityRefs {
+  return c as unknown as ConceptWithEntityRefs;
+}
+
+function conceptWithRefs(): Concept {
+  return conceptFromJson({
+    '@context': 'https://glossarist.org/ns/context.jsonld',
+    '@id': 'https://www.geolexica.org/isotc204/concept/3.1.1.1',
+    '@type': 'gl:Concept',
+    'gl:identifier': '3.1.1.1',
+    'gl:localizedConcept': {
+      eng: {
+        '@id': 'https://www.geolexica.org/isotc204/concept/3.1.1.1/eng',
+        '@type': 'gl:LocalizedConcept',
+        'gl:languageCode': 'eng',
+        'gl:entryStatus': 'valid',
+        'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'entity' }],
+      },
+    },
+    'gl:figureRef': [
+      'mixed-reflection',
+      { '@id': '../figure/dispersion-prism' },
+      { '@id': '../figure/standard-wavelengths', 'gl:display': 'Figure 3' },
+    ],
+    'gl:tableRef': [{ '@id': '../table/wavelength-table' }],
+    'gl:formulaRef': ['e-mc2'],
+  });
+}
+
+describe('conceptFromJson — structural entity refs', () => {
+  it('extracts bare-string figure refs', () => {
+    const c = refsOf(conceptWithRefs());
+    const ids = c.figures.map(f => f.entityId);
+    expect(ids).toContain('mixed-reflection');
+  });
+
+  it('extracts @id-only figure refs by last path segment', () => {
+    const c = refsOf(conceptWithRefs());
+    const ids = c.figures.map(f => f.entityId);
+    expect(ids).toContain('dispersion-prism');
+  });
+
+  it('preserves gl:display as the reference display override', () => {
+    const c = refsOf(conceptWithRefs());
+    const withDisplay = c.figures.find(f => f.entityId === 'standard-wavelengths');
+    expect(withDisplay?.display).toBe('Figure 3');
+  });
+
+  it('extracts table refs from gl:tableRef', () => {
+    const c = refsOf(conceptWithRefs());
+    expect(c.tables.map(t => t.entityId)).toContain('wavelength-table');
+  });
+
+  it('extracts formula refs from gl:formulaRef', () => {
+    const c = refsOf(conceptWithRefs());
+    expect(c.formulas.map(f => f.entityId)).toContain('e-mc2');
+  });
+
+  it('returns empty arrays when no ref fields are present', () => {
+    const c = refsOf(conceptFromJson({
+      '@context': 'https://glossarist.org/ns/context.jsonld',
+      '@id': 'https://example.org/x/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': 'x' }],
+        },
+      },
+    }));
+    expect(c.figures).toEqual([]);
+    expect(c.tables).toEqual([]);
+    expect(c.formulas).toEqual([]);
+  });
+
+  it('skips malformed entries (empty string, null, missing @id)', () => {
+    const c = refsOf(conceptFromJson({
+      '@context': 'https://glossarist.org/ns/context.jsonld',
+      '@id': 'https://example.org/x/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': 'x' }],
+        },
+      },
+      'gl:figureRef': [
+        '',
+        null,
+        {},
+        { '@id': '' },
+        { ref: '' },
+        '   ',
+      ],
+    }));
+    expect(c.figures).toEqual([]);
+  });
+});

package/src/__tests__/non-verbal-anchor.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import {
+  anchorId,
+  ANCHOR_KIND_SELECTORS,
+} from '../utils/non-verbal-anchor';
+
+describe('non-verbal-anchor', () => {
+  describe('anchorId', () => {
+    it('joins kind + datasetId + entityId with hyphens', () => {
+      expect(anchorId('figure', 'iala-2023', 'mixed-reflection'))
+        .toBe('figure-iala-2023-mixed-reflection');
+    });
+
+    it('uses the kind name as prefix (not an alias)', () => {
+      expect(anchorId('table', 'iso', 'standard-wavelengths'))
+        .toBe('table-iso-standard-wavelengths');
+      expect(anchorId('formula', 'iso', 'e-mc2'))
+        .toBe('formula-iso-e-mc2');
+    });
+  });
+
+  describe('ANCHOR_KIND_SELECTORS', () => {
+    it('contains one selector per kind', () => {
+      expect(ANCHOR_KIND_SELECTORS).toContain('a[href^="#figure-"]');
+      expect(ANCHOR_KIND_SELECTORS).toContain('a[href^="#table-"]');
+      expect(ANCHOR_KIND_SELECTORS).toContain('a[href^="#formula-"]');
+    });
+
+    it('has exactly three selectors (one per kind)', () => {
+      expect(ANCHOR_KIND_SELECTORS.length).toBe(3);
+    });
+  });
+});

package/src/__tests__/non-verbal-cross-ref.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { defineComponent, h } from 'vue';
+import { mount } from '@vue/test-utils';
+import { useNonVerbalCrossRef } from '../composables/use-non-verbal-cross-ref';
+
+const Host = defineComponent({
+  setup() {
+    const { navigateToEntity } = useNonVerbalCrossRef();
+    return { navigateToEntity };
+  },
+  render() {
+    return h('div');
+  },
+});
+
+function setHash(href: string) {
+  // jsdom-compatible history stub
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: { ...window.location, hash: '' },
+  });
+  // Some jsdom builds make location readonly; fall back to defining on the prototype chain.
+  try {
+    window.location.hash = href;
+  } catch {
+    Object.defineProperty(window.location, 'hash', { configurable: true, value: href });
+  }
+}
+
+describe('useNonVerbalCrossRef', () => {
+  let pushSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    pushSpy = vi.spyOn(window.history, 'pushState').mockImplementation(() => undefined);
+    setHash('');
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  function click(target: HTMLElement): void {
+    const ev = new MouseEvent('click', { bubbles: true, cancelable: true });
+    target.dispatchEvent(ev);
+  }
+
+  it('activates the target when a figure anchor link is clicked', async () => {
+    const wrapper = mount(Host, { attachTo: document.body });
+    const figure = document.createElement('figure');
+    figure.id = 'figure-ds-mixed';
+    const scrollSpy = vi.spyOn(figure, 'scrollIntoView').mockImplementation(() => undefined);
+    const focusSpy = vi.spyOn(figure, 'focus').mockImplementation(() => undefined);
+    document.body.appendChild(figure);
+
+    const link = document.createElement('a');
+    link.href = '#figure-ds-mixed';
+    link.textContent = 'Fig 1';
+    document.body.appendChild(link);
+
+    click(link);
+
+    expect(scrollSpy).toHaveBeenCalled();
+    expect(focusSpy).toHaveBeenCalledWith({ preventScroll: true });
+    expect(figure.classList.contains('nv-entity--highlighted')).toBe(true);
+    expect(pushSpy).toHaveBeenCalledWith(null, '', '#figure-ds-mixed');
+
+    document.body.removeChild(figure);
+    document.body.removeChild(link);
+    wrapper.unmount();
+  });
+
+  it('responds to table and formula anchor prefixes', async () => {
+    const wrapper = mount(Host, { attachTo: document.body });
+
+    for (const kind of ['table', 'formula'] as const) {
+      const target = document.createElement('div');
+      target.id = `${kind}-ds-foo`;
+      const scrollSpy = vi.spyOn(target, 'scrollIntoView').mockImplementation(() => undefined);
+      document.body.appendChild(target);
+
+      const link = document.createElement('a');
+      link.href = `#${kind}-ds-foo`;
+      document.body.appendChild(link);
+
+      click(link);
+      expect(scrollSpy).toHaveBeenCalled();
+      vi.mocked(scrollSpy).mockRestore();
+
+      document.body.removeChild(target);
+      document.body.removeChild(link);
+    }
+    wrapper.unmount();
+  });
+
+  it('ignores clicks on links that are not entity anchors', async () => {
+    const wrapper = mount(Host, { attachTo: document.body });
+    const otherEl = document.createElement('div');
+    otherEl.id = 'something-else';
+    const scrollSpy = vi.spyOn(otherEl, 'scrollIntoView').mockImplementation(() => undefined);
+    document.body.appendChild(otherEl);
+
+    const link = document.createElement('a');
+    link.href = '#something-else';
+    document.body.appendChild(link);
+
+    click(link);
+    expect(scrollSpy).not.toHaveBeenCalled();
+    expect(pushSpy).not.toHaveBeenCalled();
+
+    document.body.removeChild(otherEl);
+    document.body.removeChild(link);
+    wrapper.unmount();
+  });
+
+  it('does not activate when the target element is missing', async () => {
+    const wrapper = mount(Host, { attachTo: document.body });
+    const link = document.createElement('a');
+    link.href = '#figure-ds-missing';
+    document.body.appendChild(link);
+
+    expect(() => click(link)).not.toThrow();
+    expect(pushSpy).not.toHaveBeenCalled();
+
+    document.body.removeChild(link);
+    wrapper.unmount();
+  });
+
+  it('navigateToEntity activates a known target programmatically', async () => {
+    const wrapper = mount(Host, { attachTo: document.body });
+    const target = document.createElement('figure');
+    target.id = 'figure-ds-prog';
+    const scrollSpy = vi.spyOn(target, 'scrollIntoView').mockImplementation(() => undefined);
+    document.body.appendChild(target);
+
+    (wrapper.vm as unknown as { navigateToEntity: (id: string) => void })
+      .navigateToEntity('figure-ds-prog');
+
+    expect(scrollSpy).toHaveBeenCalled();
+    expect(target.classList.contains('nv-entity--highlighted')).toBe(true);
+
+    document.body.removeChild(target);
+    wrapper.unmount();
+  });
+});

package/src/__tests__/non-verbal-highlight.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { highlightEntity, scrollToEntity } from '../utils/non-verbal-highlight';
+
+describe('non-verbal-highlight', () => {
+  let el: HTMLElement;
+  let focusSpy: ReturnType<typeof vi.spyOn>;
+  let scrollIntoViewSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    el = document.createElement('div');
+    focusSpy = vi.spyOn(el, 'focus').mockImplementation(() => undefined);
+    scrollIntoViewSpy = vi.spyOn(el, 'scrollIntoView').mockImplementation(() => undefined);
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it('adds the highlight class and tabindex', () => {
+    highlightEntity(el);
+    expect(el.classList.contains('nv-entity--highlighted')).toBe(true);
+    expect(el.getAttribute('tabindex')).toBe('-1');
+  });
+
+  it('focuses the element without scrolling', () => {
+    highlightEntity(el);
+    expect(focusSpy).toHaveBeenCalledWith({ preventScroll: true });
+  });
+
+  it('removes the highlight class after the duration', () => {
+    highlightEntity(el);
+    expect(el.classList.contains('nv-entity--highlighted')).toBe(true);
+    vi.advanceTimersByTime(2000);
+    expect(el.classList.contains('nv-entity--highlighted')).toBe(false);
+  });
+
+  it('is a no-op for null target', () => {
+    expect(() => highlightEntity(null)).not.toThrow();
+  });
+
+  it('scrollToEntity uses smooth behavior when smooth=true', () => {
+    scrollToEntity(el, true);
+    expect(scrollIntoViewSpy).toHaveBeenCalledWith({ behavior: 'smooth', block: 'start' });
+  });
+
+  it('scrollToEntity uses auto behavior when smooth=false', () => {
+    scrollToEntity(el, false);
+    expect(scrollIntoViewSpy).toHaveBeenCalledWith({ behavior: 'auto', block: 'start' });
+  });
+
+  it('scrollToEntity is a no-op for null target', () => {
+    expect(() => scrollToEntity(null, true)).not.toThrow();
+  });
+});

package/src/__tests__/non-verbal-kind.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import {
+  KIND_TO_DIR,
+  KIND_TO_BRIDGE,
+  ALL_KINDS,
+  MENTION_KIND_TO_ENTITY_KIND,
+  entityKindFromMentionKind,
+  kindFromType,
+} from '../adapters/non-verbal/kind';
+
+describe('non-verbal kind dispatch', () => {
+  describe('KIND_TO_DIR', () => {
+    it('maps each kind to its plural directory name', () => {
+      expect(KIND_TO_DIR.figure).toBe('figures');
+      expect(KIND_TO_DIR.table).toBe('tables');
+      expect(KIND_TO_DIR.formula).toBe('formulas');
+    });
+
+    it('is frozen (immutable at runtime)', () => {
+      expect(Object.isFrozen(KIND_TO_DIR)).toBe(true);
+    });
+  });
+
+  describe('ALL_KINDS', () => {
+    it('includes figure, table, formula', () => {
+      expect(ALL_KINDS).toContain('figure');
+      expect(ALL_KINDS).toContain('table');
+      expect(ALL_KINDS).toContain('formula');
+    });
+  });
+
+  describe('KIND_TO_BRIDGE', () => {
+    it('maps every kind to a function', () => {
+      for (const kind of ALL_KINDS) {
+        expect(typeof KIND_TO_BRIDGE[kind]).toBe('function');
+      }
+    });
+  });
+
+  describe('MENTION_KIND_TO_ENTITY_KIND', () => {
+    it('maps parseMention kinds to entity kinds', () => {
+      expect(MENTION_KIND_TO_ENTITY_KIND['fig-ref']).toBe('figure');
+      expect(MENTION_KIND_TO_ENTITY_KIND['table-ref']).toBe('table');
+      expect(MENTION_KIND_TO_ENTITY_KIND['formula-ref']).toBe('formula');
+    });
+  });
+
+  describe('entityKindFromMentionKind', () => {
+    it('returns the entity kind for known mention kinds', () => {
+      expect(entityKindFromMentionKind('fig-ref')).toBe('figure');
+      expect(entityKindFromMentionKind('table-ref')).toBe('table');
+      expect(entityKindFromMentionKind('formula-ref')).toBe('formula');
+    });
+
+    it('returns null for unknown mention kinds', () => {
+      expect(entityKindFromMentionKind('cite-ref')).toBeNull();
+      expect(entityKindFromMentionKind('numeric')).toBeNull();
+      expect(entityKindFromMentionKind('unknown')).toBeNull();
+    });
+  });
+
+  describe('kindFromType', () => {
+    it('accepts gl: prefix', () => {
+      expect(kindFromType('gl:Figure')).toBe('figure');
+      expect(kindFromType('gl:Table')).toBe('table');
+      expect(kindFromType('gl:Formula')).toBe('formula');
+    });
+
+    it('accepts gloss: prefix', () => {
+      expect(kindFromType('gloss:Figure')).toBe('figure');
+    });
+
+    it('returns null for unknown type', () => {
+      expect(kindFromType('gl:Unknown')).toBeNull();
+    });
+  });
+});

package/src/__tests__/non-verbal-list.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import NonVerbalList from '../components/non-verbal/NonVerbalList.vue';
+import type { StructuralEntityRef } from '../composables/use-concept-entities';
+
+function makeRef(overrides: Partial<StructuralEntityRef> = {}): StructuralEntityRef {
+  return {
+    kind: 'figure',
+    entityId: 'mixed-reflection',
+    display: null,
+    anchor: 'figure-ds-mixed-reflection',
+    ...overrides,
+  };
+}
+
+describe('NonVerbalList.vue', () => {
+  it('renders nothing when refs is empty', () => {
+    const wrapper = mount(NonVerbalList, { props: { refs: [] } });
+    expect(wrapper.find('.section-label').exists()).toBe(false);
+  });
+
+  it('renders one group per kind', () => {
+    const wrapper = mount(NonVerbalList, {
+      props: {
+        refs: [
+          makeRef({ kind: 'figure', entityId: 'foo', anchor: 'figure-ds-foo' }),
+          makeRef({ kind: 'table', entityId: 'bar', anchor: 'table-ds-bar' }),
+        ],
+      },
+    });
+    expect(wrapper.text()).toContain('Figures');
+    expect(wrapper.text()).toContain('Tables');
+  });
+
+  it('links to the anchor href', () => {
+    const wrapper = mount(NonVerbalList, {
+      props: {
+        refs: [makeRef({ kind: 'figure', entityId: 'mixed', anchor: 'figure-ds-mixed' })],
+      },
+    });
+    const a = wrapper.find('a[href="#figure-ds-mixed"]');
+    expect(a.exists()).toBe(true);
+  });
+
+  it('uses display when present, falls back to entityId', () => {
+    const wrapper = mount(NonVerbalList, {
+      props: {
+        refs: [
+          makeRef({ entityId: 'mixed', display: 'Figure 3', anchor: 'figure-ds-mixed' }),
+          makeRef({ entityId: 'plain', display: null, anchor: 'figure-ds-plain' }),
+        ],
+      },
+    });
+    expect(wrapper.text()).toContain('Figure 3');
+    expect(wrapper.text()).toContain('plain');
+  });
+
+  it('shows the raw ID as a secondary label when display is present', () => {
+    const wrapper = mount(NonVerbalList, {
+      props: {
+        refs: [makeRef({ entityId: 'dispersion-prism', display: 'Figure 3', anchor: 'figure-ds-x' })],
+      },
+    });
+    const item = wrapper.find('.nv-list__id');
+    expect(item.text()).toBe('dispersion-prism');
+  });
+});

package/src/__tests__/non-verbal-rep-display.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import type { NonVerbRep } from 'glossarist';
+import NonVerbalRepDisplay from '../components/NonVerbalRepDisplay.vue';
+import { resetFactory } from '../adapters/factory';
+
+// glossarist-js's published `.d.ts` declares NonVerbRep's constructor with 0
+// args, but the V3 runtime accepts a plain-data initializer. Cast through
+// `unknown` at this boundary. See TODO.figures/19.
+function makeRep(data: Record<string, unknown>): NonVerbRep {
+  return data as unknown as NonVerbRep;
+}
+
+function makeRouter() {
+  return createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/concept/:conceptId', name: 'concept', component: { template: '<div/>' } },
+    ],
+  });
+}
+
+describe('NonVerbalRepDisplay.vue — V3 shape', () => {
+  beforeEach(() => {
+    resetFactory();
+    setActivePinia(createPinia());
+  });
+
+  it('renders nothing when reps is empty', () => {
+    const wrapper = mount(NonVerbalRepDisplay, {
+      props: { reps: [], locale: 'eng', registerId: 'ds' },
+    });
+    expect(wrapper.find('.section-label').exists()).toBe(false);
+  });
+
+  it('renders a figure per rep', () => {
+    const rep = makeRep({
+      type: 'photograph',
+      images: [{ src: 'fig.png', format: 'png' }],
+      alt: { eng: 'A diagram' },
+    });
+    const wrapper = mount(NonVerbalRepDisplay, {
+      props: { reps: [rep], locale: 'eng', registerId: 'ds' },
+    });
+    expect(wrapper.findAll('figure').length).toBe(1);
+    expect(wrapper.text()).toContain('photograph');
+  });
+
+  it('renders the localized caption when present', () => {
+    const rep = makeRep({
+      type: 'photo',
+      caption: { eng: 'Figure 1' },
+    });
+    const wrapper = mount(NonVerbalRepDisplay, {
+      props: { reps: [rep], locale: 'eng', registerId: 'ds' },
+    });
+    expect(wrapper.text()).toContain('Figure 1');
+  });
+
+  it('renders sources when present', async () => {
+    const rep = makeRep({
+      type: 'photo',
+      sources: [
+        {
+          type: 'authoritative',
+          origin: {
+            ref: { source: 'ISO 123' },
+            locality: { type: 'clause', referenceFrom: '1.2' },
+          },
+        },
+      ],
+    });
+    const router = makeRouter();
+    await router.push('/');
+    const wrapper = mount(NonVerbalRepDisplay, {
+      props: { reps: [rep], locale: 'eng', registerId: 'ds' },
+      global: { plugins: [router] },
+    });
+    expect(wrapper.text()).toContain('Sources');
+    expect(wrapper.text()).toContain('ISO 123');
+  });
+});