@glossarist/concept-browser 0.7.100 → 0.7.102

package/src/__tests__/components/learn/learn-card-dimension-card.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import LearnCard from '../../../components/learn/LearnCard.vue';
+import DimensionCard from '../../../components/learn/DimensionCard.vue';
+
+describe('LearnCard', () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  it('renders the title and ISO reference', () => {
+    const w = mount(LearnCard, {
+      props: { title: 'partitive relation', isoReference: 'ISO 704:2022 §5.5.4.3' },
+    });
+    expect(w.find('h3').text()).toBe('partitive relation');
+    expect(w.find('.font-mono').text()).toBe('ISO 704:2022 §5.5.4.3');
+  });
+
+  it('renders the body slot', () => {
+    const w = mount(LearnCard, {
+      props: { title: 'x' },
+      slots: { default: '<p>Body content</p>' },
+    });
+    expect(w.find('.learn-card-body').html()).toContain('Body content');
+  });
+
+  it('renders the example slot in its own section', () => {
+    const w = mount(LearnCard, {
+      props: { title: 'x' },
+      slots: { example: 'VIM 1.9 measurement unit' },
+    });
+    expect(w.find('.learn-card-example').text()).toContain('VIM 1.9');
+  });
+
+  it('omits the "learn more" footer when learnMoreUrl is absent', () => {
+    const w = mount(LearnCard, { props: { title: 'x' } });
+    expect(w.find('.learn-card-footer').exists()).toBe(false);
+  });
+
+  it('renders the learn-more footer when learnMoreUrl is present', () => {
+    const w = mount(LearnCard, {
+      props: { title: 'x', learnMoreUrl: 'https://www.glossarist.org/model/x' },
+    });
+    const link = w.find('.learn-card-footer a');
+    expect(link.attributes('href')).toBe('https://www.glossarist.org/model/x');
+    expect(link.attributes('target')).toBe('_blank');
+    expect(link.attributes('rel')).toBe('noopener');
+  });
+
+  it('binds the id prop for deep-link anchors', () => {
+    const w = mount(LearnCard, {
+      props: { id: '__partitive__', title: 'x' },
+    });
+    expect(w.find('article').attributes('id')).toBe('__partitive__');
+  });
+});
+
+describe('DimensionCard', () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  it('renders one row per value', () => {
+    const w = mount(DimensionCard, {
+      props: {
+        name: 'Presence',
+        summary: 'Compulsory or optional',
+        values: [
+          { value: 'required', label: 'required', meaning: 'must be present' },
+          { value: 'optional', label: 'optional', meaning: 'may be absent' },
+        ],
+      },
+    });
+    expect(w.findAll('.dimension-value-row').length).toBe(2);
+  });
+
+  it('renders value labels and meanings', () => {
+    const w = mount(DimensionCard, {
+      props: {
+        name: 'x',
+        summary: 's',
+        values: [{ value: 'required', label: 'required', meaning: 'must be present' }],
+      },
+    });
+    const row = w.find('.dimension-value-row');
+    expect(row.text()).toContain('required');
+    expect(row.text()).toContain('must be present');
+  });
+
+  it('exposes a visual scoped slot per value', () => {
+    const w = mount(DimensionCard, {
+      props: {
+        name: 'x',
+        summary: 's',
+        values: [{ value: 'required', label: 'required', meaning: 'm' }],
+      },
+      slots: {
+        visual: '<svg data-test="custom-visual" />',
+      },
+    });
+    expect(w.find('svg[data-test="custom-visual"]').exists()).toBe(true);
+  });
+
+  it('binds the id prop for deep-link anchors', () => {
+    const w = mount(DimensionCard, {
+      props: {
+        id: 'partitive-presence',
+        name: 'x',
+        summary: 's',
+        values: [{ value: 'required', label: 'required', meaning: 'm' }],
+      },
+    });
+    expect(w.find('article').attributes('id')).toBe('partitive-presence');
+  });
+});

package/src/__tests__/composables/use-concept-edges-v2.test.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck — TODO.typescript/12: remove after glossarist TS migration
 import { describe, it, expect } from 'vitest';
 // glossarist 0.4.33 renamed PartitiveRelation → PartitiveHyperedge.
 // Import from glossarist/models (extended by our local augmentation).

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

@@ -197,8 +197,8 @@ describe('designation target matching robustness', () => {
     // Terms are in model order, not raw order
     const pdf = lc.terms.find(t => t.designation === 'PDF')!;
     const iso = lc.terms.find(t => t.designation === 'ISO')!;
-    expect(getDesignationTarget(pdf.related[0])).toBe('Portable Document Format');
-    expect(getDesignationTarget(iso.related[0])).toBe('International Organization for Standardization');
+    expect(getDesignationTarget(pdf.related[0] as any)).toBe('Portable Document Format');
+    expect(getDesignationTarget(iso.related[0] as any)).toBe('International Organization for Standardization');
   });
 });
 

package/src/__tests__/perf/serialization-perf.test.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck — TODO.typescript/12: remove after glossarist TS migration
 import { describe, it, expect } from 'vitest';
 import { Concept } from 'glossarist';
 import { conceptToQuads, collectQuads, writeTurtleSync, PREFIXES } from 'glossarist/rdf';

package/src/__tests__/use-rdf-document.test.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck — TODO.typescript/12: remove after glossarist TS migration
 import { describe, it, expect } from 'vitest';
 import { ref } from 'vue';
 import { Concept } from 'glossarist';

package/src/__tests__/views/learn/learn-designations-view.test.ts

@@ -0,0 +1,84 @@
+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 LearnDesignationsView from '../../../views/learn/LearnDesignationsView.vue';
+
+async function makeRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/learn/designations', name: 'learn-designations', component: LearnDesignationsView },
+    ],
+  });
+  await router.push('/learn/designations');
+  await router.isReady();
+  return router;
+}
+
+describe('LearnDesignationsView', () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  it('renders the page header', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnDesignationsView, { global: { plugins: [router] } });
+    expect(w.find('h1').text()).toContain('Designations');
+  });
+
+  it('renders three top-level sections (normative, kinds, types)', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnDesignationsView, { global: { plugins: [router] } });
+    const sections = w.findAll('section[aria-label]');
+    expect(sections.length).toBe(3);
+  });
+
+  it('normative section has all three ratings (preferred/admitted/deprecated)', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnDesignationsView, { global: { plugins: [router] } });
+    const normative = w.find('section[aria-label="Normative status"]');
+    const cardTitles = normative.findAll('h3').map(h => h.text());
+    expect(cardTitles).toEqual(expect.arrayContaining([
+      'preferred term', 'admitted term', 'deprecated term',
+    ]));
+  });
+
+  it('each normative card notes "there can be more than one"', async () => {
+    /* The user's specific concern: explain that there can be multiple. */
+    const router = await makeRouter();
+    const w = mount(LearnDesignationsView, { global: { plugins: [router] } });
+    const normative = w.find('section[aria-label="Normative status"]');
+    const notes = normative.findAll('.italic').map(i => i.text().toLowerCase());
+    expect(notes.filter(t => t.includes('more than one')).length).toBe(3);
+  });
+
+  it('kinds section renders all four kinds (full form, abbreviated, borrowed, variant)', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnDesignationsView, { global: { plugins: [router] } });
+    const kinds = w.find('section[aria-label="Kinds and forms of term"]');
+    const titles = kinds.findAll('h3').map(h => h.text());
+    expect(titles).toEqual(expect.arrayContaining([
+      'full form', 'abbreviated form', 'borrowed term', 'variant',
+    ]));
+  });
+
+  it('types section renders term, acronym, initialism, symbol', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnDesignationsView, { global: { plugins: [router] } });
+    const types = w.find('section[aria-label="Designation types"]');
+    const titles = types.findAll('h3').map(h => h.text());
+    expect(titles).toEqual(expect.arrayContaining([
+      'term (expression)', 'acronym', 'initialism', 'symbol',
+    ]));
+  });
+
+  it('every example slot mentions a concrete ISO example', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnDesignationsView, { global: { plugins: [router] } });
+    const examples = w.findAll('.learn-card-example').map(e => e.text());
+    expect(examples.some(t => t.includes('compact disc'))).toBe(true);
+    expect(examples.some(t => t.includes('WWW'))).toBe(true);
+    expect(examples.some(t => t.includes('laser'))).toBe(true);
+    expect(examples.some(t => t.includes('OIML'))).toBe(true);
+  });
+});

package/src/__tests__/views/learn/learn-index-view.test.ts

@@ -0,0 +1,45 @@
+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 LearnIndexView from '../../../views/learn/LearnIndexView.vue';
+
+async function makeRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/learn', name: 'learn', component: LearnIndexView },
+      { path: '/learn/relationships', name: 'learn-relationships', component: { template: '<div/>' } },
+      { path: '/learn/designations', name: 'learn-designations', component: { template: '<div/>' } },
+      { path: '/learn/statuses', name: 'learn-statuses', component: { template: '<div/>' } },
+    ],
+  });
+  await router.push('/learn');
+  await router.isReady();
+  return router;
+}
+
+describe('LearnIndexView', () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  it('renders the page header with translated title', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnIndexView, { global: { plugins: [router] } });
+    expect(w.find('h1').text()).toContain('Learn');
+  });
+
+  it('renders exactly 3 topic cards for Phase 1', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnIndexView, { global: { plugins: [router] } });
+    /* Each RouterLink wraps a LearnCard. Phase 1 = 3 topics. */
+    expect(w.findAllComponents({ name: 'LearnCard' }).length).toBe(3);
+  });
+
+  it('each topic card links to one of the Phase 1 routes', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnIndexView, { global: { plugins: [router] } });
+    const links = w.findAll('a').map(a => a.attributes('href'));
+    expect(links).toEqual(expect.arrayContaining(['/learn/relationships', '/learn/designations', '/learn/statuses']));
+  });
+});

package/src/__tests__/views/learn/learn-relationships-view.test.ts

@@ -0,0 +1,83 @@
+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 LearnRelationshipsView from '../../../views/learn/LearnRelationshipsView.vue';
+
+async function makeRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/learn/relationships', name: 'learn-relationships', component: LearnRelationshipsView },
+    ],
+  });
+  await router.push('/learn/relationships');
+  await router.isReady();
+  return router;
+}
+
+describe('LearnRelationshipsView', () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  it('renders the page header with translated title', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    expect(w.find('h1').text()).toContain('Relationships');
+  });
+
+  it('renders three top-level sections (bilateral, partitive, general)', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const sections = w.findAll('section[aria-label]');
+    expect(sections.length).toBe(3);
+  });
+
+  it('renders the hyperedge cards with the expected anchors', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const ids = w.findAll('.learn-card[id]').map(c => c.attributes('id'));
+    expect(ids).toContain('__partitive__');
+    expect(ids).toContain('__generic__');
+  });
+
+  it('renders three DimensionCards for the partitive dimensions', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const dimIds = w.findAll('.dimension-card[id]').map(c => c.attributes('id'));
+    expect(dimIds).toEqual(expect.arrayContaining(['partitive-presence', 'partitive-count', 'partitive-delimiting']));
+  });
+
+  it('renders the bilateral section grouped by category', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const bilateralArticles = w.find('section[aria-label="Bilateral relations (one-to-one)"]').findAll('article');
+    expect(bilateralArticles.length).toBeGreaterThanOrEqual(5);
+  });
+
+  it('every bilateral type row has an id anchor matching the type key', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const rows = w.findAll('.bilateral-row');
+    expect(rows.length).toBeGreaterThan(10);
+    for (const row of rows) {
+      const id = row.attributes('id');
+      expect(id).toBeTruthy();
+      expect(id).toMatch(/^[a-z_]+$/);
+    }
+  });
+
+  it('renders a live diagram for each hyperedge card', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    expect(w.findAll('svg.hyperedge-diagram').length).toBe(2);
+  });
+
+  it('renders ISO references on each hyperedge card', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnRelationshipsView, { global: { plugins: [router] } });
+    const isoRefs = w.findAll('.learn-card span.font-mono').map(s => s.text());
+    expect(isoRefs.some(t => t.includes('ISO 704:2022 §5.5.4.3'))).toBe(true);
+    expect(isoRefs.some(t => t.includes('ISO 704:2022 §5.5.4.2'))).toBe(true);
+  });
+});

package/src/__tests__/views/learn/learn-statuses-view.test.ts

@@ -0,0 +1,60 @@
+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 LearnStatusesView from '../../../views/learn/LearnStatusesView.vue';
+
+async function makeRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/learn/statuses', name: 'learn-statuses', component: LearnStatusesView },
+      { path: '/learn/designations', name: 'learn-designations', component: { template: '<div/>' } },
+    ],
+  });
+  await router.push('/learn/statuses');
+  await router.isReady();
+  return router;
+}
+
+describe('LearnStatusesView', () => {
+  beforeEach(() => setActivePinia(createPinia()));
+
+  it('renders the page header', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    expect(w.find('h1').text()).toContain('Statuses');
+  });
+
+  it('renders three top-level sections (entry, normative, source)', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    const sections = w.findAll('section[aria-label]');
+    expect(sections.length).toBe(3);
+  });
+
+  it('entry section renders all four entry statuses with anchors', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    const entrySection = w.find('section[aria-label="Entry status"]');
+    const ids = entrySection.findAll('.learn-card[id]').map(c => c.attributes('id'));
+    expect(ids).toEqual(expect.arrayContaining(['entry-valid', 'entry-withdrawn', 'entry-draft', 'entry-superseded']));
+  });
+
+  it('normative section cross-links to /learn/designations', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    const normative = w.find('section[aria-label="Normative status"]');
+    const link = normative.find('a');
+    expect(link.attributes('href')).toBe('/learn/designations');
+  });
+
+  it('source section renders the four source statuses with anchors', async () => {
+    const router = await makeRouter();
+    const w = mount(LearnStatusesView, { global: { plugins: [router] } });
+    const sourceSection = w.find('section[aria-label="Source status"]');
+    const ids = sourceSection.findAll('.learn-card[id]').map(c => c.attributes('id'));
+    expect(ids).toEqual(expect.arrayContaining(['source-identical', 'source-modified', 'source-restyled', 'source-lineage']));
+  });
+});

package/src/adapters/bibliography-adapter.ts

@@ -38,7 +38,7 @@ export class BibliographyAdapter {
     return this.data?.find(id) ?? null;
   }
 
-  all(): BibliographyEntry[] {
+  all(): readonly BibliographyEntry[] {
     return this.data?.entries ?? [];
   }
 

package/src/adapters/model-bridge.ts

@@ -61,7 +61,7 @@ import type {
   JsonLdPartitiveMember,
   JsonLdPartitiveRelation,
   JsonLdConcept,
-} from './model-bridge/jsonld-types';
+} from './jsonld-types';
 
 // ── Bridges for fields not yet in glossarist-js ────────────────────────────
 // Remove each bridge when glossarist-js publishes native support.
@@ -173,7 +173,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?: Record<string, string> | string | null; ref?: any; related?: any[] }>,
+  modelRelated: ReadonlyArray<{ type?: string | null; content?: Record<string, string> | string | null; ref?: any; related?: ReadonlyArray<any> }>,
   rawRelated: unknown[],
 ): void {
   for (const rawRel of rawRelated) {
@@ -241,7 +241,7 @@ function mapDesignationFromJsonLd(d: JsonLdDesignation): Record<string, unknown>
 
   const pronunciation = d[GL.PRONUNCIATION];
   if (pronunciation?.length) {
-    result.pronunciation = pronunciation.map(p => ({
+    result.pronunciation = pronunciation.map((p: any) => ({
       content: p[GL.CONTENT] ?? null,
       language: p[GL.LANGUAGE] ?? null,
       script: p[GL.SCRIPT] ?? null,
@@ -257,7 +257,7 @@ function mapDesignationFromJsonLd(d: JsonLdDesignation): Record<string, unknown>
 
   const related = d[GL.RELATED];
   if (related?.length) {
-    result.related = related.map(r => {
+    result.related = related.map((r: any) => {
       const relType = r[GL.RELATIONSHIP_TYPE] ?? 'references';
       if (DESIGNATION_REL_TYPES.has(relType) && r[GL.TARGET]) {
         return { type: relType, target: r[GL.TARGET] };
@@ -272,7 +272,7 @@ function mapDesignationFromJsonLd(d: JsonLdDesignation): Record<string, unknown>
   }
   const grammarInfo = d[GL.GRAMMAR_INFO];
   if (grammarInfo?.length) {
-    result.grammar_info = grammarInfo.map(gi => ({
+    result.grammar_info = grammarInfo.map((gi: any) => ({
       gender: gi[GL.GENDER] ?? null,
       number: gi[GL.NUMBER] ?? null,
       part_of_speech: gi[GL.PART_OF_SPEECH] ?? null,
@@ -354,7 +354,7 @@ function mapSourceFromJsonLd(s: JsonLdSource): Record<string, unknown> {
 
   const sf = s[GL.SOURCED_FROM] ?? s[GL.SOURCED_FROM_ALT];
   if (sf?.length) {
-    result.sourced_from = sf.map(item => mapOriginFromJsonLd(item));
+    result.sourced_from = sf.map((item: any) => mapOriginFromJsonLd(item));
   }
 
   return result;
@@ -445,7 +445,7 @@ function mapLocalizedFromJsonLd(lc: JsonLdLocalizedConcept): Record<string, unkn
 
   const dates = lc[GL.DATES];
   if (dates?.length) {
-    data.dates = dates.map(d => ({
+    data.dates = dates.map((d: any) => ({
       date: d[GL.DATE] ?? null,
       type: d[GL.DATE_TYPE] ?? null,
     }));
@@ -471,7 +471,7 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
   if (!comprehensive) return null;
 
   const partitives = (r[GL.HAS_PARTITIVE] ?? [])
-    .map((m): Record<string, unknown> | null => {
+    .map((m: any): Record<string, unknown> | null => {
       const ref = m[GL.REF] ? mapRefFromJsonLd(m[GL.REF]) : null;
       if (!ref) return null;
       const out: Record<string, unknown> = { ref };
@@ -494,7 +494,7 @@ function mapPartitiveRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<stri
       if (m[GL.IS_DELIMITING] === true) out.is_delimiting = true;
       return out;
     })
-    .filter((m): m is Record<string, unknown> => m !== null);
+    .filter((m: any): m is Record<string, unknown> => m !== null);
 
   // ISO 704 requires ≥2 partitives. Skip malformed relations rather
   // than letting the constructor throw and break the whole concept.
@@ -529,7 +529,7 @@ function mapGenericRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<string
   if (!comprehensive) return null;
 
   const members = (r[GL.HAS_GENERIC] ?? [])
-    .map((m): Record<string, unknown> | null => {
+    .map((m: any): Record<string, unknown> | null => {
       const ref = m[GL.REF] ? mapRefFromJsonLd(m[GL.REF]) : null;
       if (!ref) return null;
       const out: Record<string, unknown> = { ref };
@@ -552,7 +552,7 @@ function mapGenericRelationFromJsonLd(r: JsonLdPartitiveRelation): Record<string
       }
       return out;
     })
-    .filter((m): m is Record<string, unknown> => m !== null);
+    .filter((m: any): m is Record<string, unknown> => m !== null);
 
   if (members.length < 2) return null;
 
@@ -589,7 +589,7 @@ function splitMultiplicity(m: string): { presence: 'required' | 'optional'; coun
 
 function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   const id = String(doc[GL.IDENTIFIER] ?? doc['@id']?.split('/').pop() ?? '');
-  const localizations: Record<string, unknown> = {};
+  const localizations: Record<string, Record<string, unknown>> = {};
 
   const rawLc = doc[GL.LOCALIZED_CONCEPT] ?? {};
   for (const [lang, lc] of Object.entries(rawLc)) {
@@ -601,10 +601,10 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
   const related = (doc[GL.RELATED] ?? []).map(mapRelatedFromJsonLd);
   const partitiveRelations = (doc[GL.PARTITIVE_RELATIONS] ?? [])
     .map(mapPartitiveRelationFromJsonLd)
-    .filter((r): r is Record<string, unknown> => r !== null);
+    .filter((r: any): r is Record<string, unknown> => r !== null);
   const genericRelations = (doc[GL.GENERIC_RELATIONS] ?? [])
     .map(mapGenericRelationFromJsonLd)
-    .filter((r): r is Record<string, unknown> => r !== null);
+    .filter((r: any): r is Record<string, unknown> => r !== null);
   const tagsArr = doc[GL.TAGS];
   const tags = Array.isArray(tagsArr) ? [...tagsArr] : [];
 
@@ -612,7 +612,7 @@ function conceptFromJsonLd(doc: JsonLdConcept): Concept {
     id,
     term: doc[GL.TERM] ?? null,
     uri: doc['@id'] ?? null,
-    localizations,
+    localizations: localizations as Record<string, any>,
     related,
     partitive_relations: partitiveRelations,
     generic_relations: genericRelations,

package/src/adapters/non-verbal/figure-bridge.ts

@@ -48,7 +48,7 @@ function imageFromJsonLd(raw: Record<string, unknown>): FigureImage | null {
     ...(typeof width === 'number' && { width }),
     ...(typeof height === 'number' && { height }),
     ...(typeof scale === 'number' && { scale }),
-  });
+  } as any);
 }
 
 function imagesFromJsonLd(raw: unknown): FigureImage[] {
@@ -96,5 +96,5 @@ export function figureFromJsonLd(doc: Record<string, unknown>): Figure | null {
     ...(description && { description }),
     ...(subfigures && { subfigures }),
     ...(sources.length && { sources }),
-  });
+  } as any);
 }

package/src/adapters/non-verbal/formula-bridge.ts

@@ -40,11 +40,11 @@ export function formulaFromJsonLd(doc: Record<string, unknown>): Formula | null
 
   return new Formula({
     id,
-    expression,
+    expression: expression as any,
     notation,
     ...(identifier && { identifier }),
     ...(caption && { caption }),
     ...(description && { description }),
     ...(sources.length && { sources }),
-  });
+  } as any);
 }

package/src/adapters/non-verbal/table-bridge.ts

@@ -90,11 +90,11 @@ export function tableFromJsonLd(doc: Record<string, unknown>): Table | null {
 
   return new Table({
     id,
-    content: content as Record<string, unknown>,
+    content: content as any,
     ...(identifier && { identifier }),
     ...(caption && { caption }),
     ...(description && { description }),
     ...(format && { format }),
     ...(sources.length && { sources }),
-  });
+  } as any);
 }

package/src/components/CitationDisplay.vue

@@ -107,7 +107,7 @@ async function loadPreview() {
     const def = lc?.definitions?.[0]?.content || concept.definition('eng');
     const term = lc?.terms?.[0]?.designation || concept.primaryDesignation('eng');
     preview.value = {
-      designation: term || entry?.designations?.eng || conceptId,
+      designation: String(term || entry?.designations?.eng || conceptId),
       definition: typeof def === 'string' ? def.slice(0, 200) : '',
     };
   } catch {

package/src/components/ConceptDetail.vue

@@ -200,7 +200,7 @@ function getTermForLang(lang: string): string {
 
 function getDesignationsForLang(lang: string): Designation[] {
   const lc = props.concept.localization(lang);
-  return lc?.terms ?? [];
+  return [...(lc?.terms ?? [])];
 }
 
 function hasDefinition(lang: string): boolean {
@@ -444,7 +444,7 @@ const nonVerbalReps = computed(() => {
               </div>
 
               <!-- Non-verbal representations -->
-              <NonVerbalRepDisplay v-if="lc.lc.nonVerbalRep?.length" :reps="lc.lc.nonVerbalRep" :locale="lc.lang" :register-id="registerId" :dataset-locales="languages" />
+              <NonVerbalRepDisplay v-if="lc.lc.nonVerbalRep?.length" :reps="[...lc.lc.nonVerbalRep]" :locale="lc.lang" :register-id="registerId" :dataset-locales="languages" />
 
               <!-- Sources -->
               <div v-if="lc.sources.length" class="space-y-2">

package/src/components/ConceptDiffModal.vue

@@ -33,7 +33,7 @@ const { t } = useI18n();
 const targetConcept = ref<Concept | null>(null);
 const loadError = ref<string | null>(null);
 
-function conceptToData(c: Concept | null, registerId: string): ConceptLikeData | null {
+function conceptToData(c: any, registerId: string): ConceptLikeData | null {
   if (!c) return null;
   const langs = c.languages ?? [];
   const localizations: Record<string, unknown> = {};
@@ -51,7 +51,7 @@ function conceptToData(c: Concept | null, registerId: string): ConceptLikeData |
 }
 
 const oldData = computed(() => conceptToData(targetConcept.value, props.targetRegisterId));
-const newData = computed(() => conceptToData(props.currentConcept, props.currentRegisterId));
+const newData = computed(() => conceptToData(props.currentConcept as any, props.currentRegisterId));
 
 async function loadTarget() {
   if (!props.open || !props.targetRegisterId || !props.targetConceptId) return;

package/src/components/ConceptDiffView.vue

@@ -51,7 +51,7 @@ watchEffect(() => {
   }
 });
 
-const effectiveDiff = computed(() => props.diff ?? internal.diffResult.value);
+const effectiveDiff = computed(() => (props.diff ?? internal.diffResult.value) as any);
 const sections = computed(() => deriveDiffSections(effectiveDiff.value, props.lang));
 const similarity = computed(() => computeSimilarity(effectiveDiff.value));
 const hasChanges = computed(() => effectiveDiff.value?.hasChanges === true);