@glossarist/concept-browser 0.7.113 → 0.7.115

package/src/__tests__/scripts/dataset-turtle.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { Parser, Store } from 'n3';
-import { buildDatasetTurtle } from '../../../scripts/lib/dataset-turtle.mjs';
+import { buildDatasetTurtle } from '../../../scripts/lib/dataset-turtle';
 
 const BASE = 'https://glossarist.org/dataset';
 

package/src/__tests__/scripts/migrate-v1-to-v3.test.ts

@@ -5,7 +5,7 @@ import {
   migrateRelation,
   migrateConceptData,
   isAlreadyMigrated,
-} from '../../../scripts/migrate-v1-to-v3.mjs';
+} from '../../../scripts/migrate-v1-to-v3';
 
 describe('migrate-v1-to-v3 pure conversion', () => {
   describe('isV1PartitiveRelation', () => {

package/src/__tests__/scripts/normalize-yaml.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtempSync, writeFileSync, readFileSync, rmSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { normalizeYaml } from '../../../scripts/normalize-yaml.mjs';
+import { normalizeYaml } from '../../../scripts/normalize-yaml';
 
 const NFC_STRING = 'café';
 const NON_NFC_STRING = 'café';

package/src/__tests__/scripts/turtle-escape.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { ttlLit, ttlPrefixed, ttlIri, assertValidIri } from '../../../scripts/lib/turtle-escape.mjs';
+import { ttlLit, ttlPrefixed, ttlIri, assertValidIri } from '../../../scripts/lib/turtle-escape';
 
 describe('D1/D2 — Turtle escaping hardening', () => {
   describe('ttlLit', () => {

package/src/__tests__/scripts/validate-yaml.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validateYaml } from '../../../scripts/validate-yaml';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SCHEMA_PATH = resolve(__dirname, '..', '..', '..', 'data', 'concept-model', 'shapes', 'glossarist.concept.yaml.schema.json');
+const schema = JSON.parse(readFileSync(SCHEMA_PATH, 'utf8'));
+
+describe('validate-yaml', () => {
+  it('accepts a valid concept with termid and localization', () => {
+    const yaml = `
+termid: '1'
+eng:
+  terms:
+    - designation: measurement unit
+      normative_status: preferred
+  definition:
+    - content: A concept used as a basis for comparison.
+`;
+    const result = validateYaml(yaml, schema);
+    if (!result.valid) console.log('Errors:', result.errors);
+    expect(result.valid).toBe(true);
+  });
+
+  it('rejects a concept without termid', () => {
+    const yaml = `
+eng:
+  terms:
+    - designation: missing id
+`;
+    const result = validateYaml(yaml, schema);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.message.includes('termid'))).toBe(true);
+  });
+
+  it('accepts managed concept format with underscore fields', () => {
+    const yaml = `
+termid: '5'
+_domains:
+  - physics
+_status: valid
+`;
+    const result = validateYaml(yaml, schema);
+    if (!result.valid) console.log('Errors:', result.errors);
+    expect(result.valid).toBe(true);
+  });
+
+  it('accepts partitive relations with MECE axes', () => {
+    const yaml = `
+termid: '3'
+_partitiveRelations:
+  - type: hasPart
+    members:
+      - ref: part-a
+        presence: required
+        count: exactly_one
+`;
+    const result = validateYaml(yaml, schema);
+    if (!result.valid) console.log('Errors:', result.errors);
+    expect(result.valid).toBe(true);
+  });
+
+  it('rejects non-string termid', () => {
+    const yaml = `
+termid: 12345
+eng:
+  terms:
+    - designation: test
+`;
+    const result = validateYaml(yaml, schema);
+    expect(result.valid).toBe(false);
+  });
+});
+

package/src/__tests__/scripts/version-turtle.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { Parser, Store } from 'n3';
-import { buildVersionTurtle, buildVersionHistoryTurtle } from '../../../scripts/lib/version-turtle.mjs';
+import { buildVersionTurtle, buildVersionHistoryTurtle } from '../../../scripts/lib/version-turtle';
 
 function parse(turtle: string): Store {
   const parser = new Parser({ format: 'Turtle' });

package/src/__tests__/scripts/vocab-turtle.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { Parser, Store } from 'n3';
-import { buildVocabularyTurtle, listVocabSchemes } from '../../../scripts/lib/vocab-turtle.mjs';
+import { buildVocabularyTurtle, listVocabSchemes } from '../../../scripts/lib/vocab-turtle';
 
 function parse(turtle: string): Store {
   const parser = new Parser({ format: 'Turtle' });

package/src/__tests__/scripts-syntax.test.ts

@@ -9,10 +9,10 @@ const repoRoot = path.resolve(
 );
 
 describe('scripts syntax gate', () => {
-  it('`npm run check:scripts` exits 0 (every .mjs/.js/.cjs in scripts/ and cli/ parses)', () => {
+  it('`npm run check:scripts` exits 0 (every .ts/.mjs/.js/.cjs in scripts/ and cli/ parses)', () => {
     const result = spawnSync(
       process.execPath,
-      [path.join(repoRoot, 'scripts', 'check-syntax.mjs')],
+      ['--import', 'tsx', path.join(repoRoot, 'scripts', 'check-syntax.ts')],
       { encoding: 'utf8' },
     );
 

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

@@ -1,10 +1,9 @@
-// @ts-nocheck — TODO.typescript/12: remove after glossarist TS migration
 import { describe, it, expect } from 'vitest';
 import { ref } from 'vue';
 import { Concept } from 'glossarist';
 import { useRdfDocument } from '../components/use-rdf-document';
 
-function makeConcept(): Concept {
+function makeConcept(): any {
   return Concept.fromJSON({
     id: '3.1.1',
     uri: 'https://glossarist.org/test/concept/3.1.1',
@@ -24,7 +23,7 @@ function makeConcept(): Concept {
   });
 }
 
-function makeConceptWithNonVerbal(): Concept {
+function makeConceptWithNonVerbal(): any {
   return Concept.fromJSON({
     id: '3.1.2',
     uri: 'https://glossarist.org/test/concept/3.1.2',

package/src/__tests__/utils/content-renderer-xss.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { renderContent } from '../../utils/content-renderer';
+
+describe('content-renderer XSS protection', () => {
+  it('blocks javascript: URLs in {{link:}} (no anchor tag)', () => {
+    const html = renderContent('{{link:javascript:alert(1)}}', {});
+    expect(html).not.toContain('<a');
+    expect(html).not.toContain('href=');
+  });
+
+  it('blocks javascript: URLs in {{link:}} with label (renders as text)', () => {
+    const html = renderContent('{{link:javascript:alert(1), click me}}', {});
+    expect(html).not.toContain('<a');
+    expect(html).not.toContain('href=');
+    expect(html).toContain('click me');
+  });
+
+  it('blocks data: URLs in {{link:}} (no anchor tag)', () => {
+    const html = renderContent('{{link:data:text/html,<script>alert(1)</script>}}', {});
+    expect(html).not.toContain('<a');
+    expect(html).not.toContain('href=');
+    expect(html).not.toContain('<script>');
+  });
+
+  it('allows https: URLs in {{link:}}', () => {
+    const html = renderContent('{{link:https://example.com}}', {});
+    expect(html).toContain('href="https://example.com"');
+  });
+
+  it('blocks javascript: URLs in {{image:}} (no img tag)', () => {
+    const html = renderContent('{{image:javascript:alert(1)}}', {});
+    expect(html).not.toContain('<img');
+  });
+
+  it('blocks data: URLs in {{image:}} (no img tag with executable src)', () => {
+    const html = renderContent('{{image:data:text/html,<script>}}', {});
+    expect(html).not.toContain('<img');
+    expect(html).not.toContain('data:text/html');
+  });
+
+  it('allows relative paths in {{image:}}', () => {
+    const html = renderContent('{{image:diagram.png}}', {});
+    expect(html).toContain('src="diagram.png"');
+  });
+
+  it('escapes HTML in unordered list items', () => {
+    const html = renderContent('* <script>alert(1)</script>\n* safe item', {});
+    expect(html).not.toContain('<script>');
+    expect(html).toContain('&lt;script&gt;');
+  });
+
+  it('escapes HTML in ordered list items', () => {
+    const html = renderContent('1. <img onerror=alert(1)>\n2. safe', {});
+    expect(html).not.toContain('<img onerror');
+    expect(html).toContain('&lt;img');
+  });
+});

package/src/__tests__/utils/inline-content-kinds.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { renderContent, cleanContent, type RenderOptions } from '../../utils/content-renderer';
+
+/**
+ * Unified mention syntax contract — {{kind:target[, label]}}.
+ *
+ * Pins the dispatch for every kind and the deprecation behavior for
+ * the legacy <<ref,title>> AsciiDoc xref syntax.
+ */
+
+describe('content-renderer — unified mention kinds', () => {
+
+  describe('{{link:URL}} — external link', () => {
+    it('renders bare URL as external anchor', () => {
+      const html = renderContent('{{link:https://example.com}}');
+      expect(html).toContain('<a href="https://example.com"');
+      expect(html).toContain('target="_blank"');
+      expect(html).toContain('rel="noopener"');
+      expect(html).toContain('https://example.com');
+    });
+
+    it('renders URL with label', () => {
+      const html = renderContent('{{link:https://example.com, click here}}');
+      expect(html).toContain('click here');
+      expect(html).toContain('href="https://example.com"');
+    });
+
+    it('delegates to linkResolver when provided', () => {
+      const opts: RenderOptions = { linkResolver: (url, label) => `<a href="${url}" class="custom">${label}</a>` };
+      const html = renderContent('{{link:https://example.com, test}}', opts);
+      expect(html).toContain('class="custom"');
+      expect(html).toContain('test');
+    });
+  });
+
+  describe('{{image:src}} — inline image embed', () => {
+    it('renders bare src as img tag', () => {
+      const html = renderContent('{{image:photo.png}}');
+      expect(html).toContain('<img');
+      expect(html).toContain('src="photo.png"');
+    });
+
+    it('renders src with alt text', () => {
+      const html = renderContent('{{image:photo.png, A photo of the setup}}');
+      expect(html).toContain('src="photo.png"');
+      expect(html).toContain('alt="A photo of the setup"');
+    });
+
+    it('delegates to imageResolver when provided', () => {
+      const opts: RenderOptions = { imageResolver: (src, alt) => `<img src="/base/${src}" alt="${alt}" class="custom-img" />` };
+      const html = renderContent('{{image:photo.png, test}}', opts);
+      expect(html).toContain('src="/base/photo.png"');
+      expect(html).toContain('class="custom-img"');
+    });
+  });
+
+  describe('{{bib:id}} — bibliography entry', () => {
+    it('renders id as bib-ref span when no resolver', () => {
+      const html = renderContent('{{bib:ref_1}}');
+      expect(html).toContain('bib-ref');
+      expect(html).toContain('ref_1');
+    });
+
+    it('renders label when provided', () => {
+      const html = renderContent('{{bib:ref_1, ISO 704}}');
+      expect(html).toContain('ISO 704');
+    });
+
+    it('delegates to bibResolver when provided', () => {
+      const opts: RenderOptions = { bibResolver: (id, title) => `<a href="/bib/${id}" class="bib-link">${title}</a>` };
+      const html = renderContent('{{bib:ref_1, ISO 704}}', opts);
+      expect(html).toContain('href="/bib/ref_1"');
+      expect(html).toContain('ISO 704');
+    });
+  });
+
+  describe('cleanContent — new kinds stripped correctly', () => {
+    it('strips {{link:URL}} to the URL', () => {
+      expect(cleanContent('{{link:https://example.com}}')).toBe('https://example.com');
+    });
+
+    it('strips {{link:URL, label}} to the label', () => {
+      expect(cleanContent('{{link:https://example.com, click here}}')).toBe('click here');
+    });
+
+    it('strips {{image:src}} to empty string', () => {
+      expect(cleanContent('{{image:photo.png}}')).toBe('');
+    });
+
+    it('strips {{image:src, alt}} to the alt text', () => {
+      expect(cleanContent('{{image:photo.png, A photo}}')).toBe('A photo');
+    });
+
+    it('strips {{bib:id}} to the id', () => {
+      expect(cleanContent('{{bib:ref_1}}')).toBe('ref_1');
+    });
+
+    it('strips {{bib:id, label}} to the label', () => {
+      expect(cleanContent('{{bib:ref_1, ISO 704}}')).toBe('ISO 704');
+    });
+  });
+});
+
+describe('content-renderer — legacy <<ref,title>> deprecation', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('emits a deprecation warning via console.warn', () => {
+    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    renderContent('See <<845-01-01, 845-01-01>> for details.');
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy.mock.calls[0][0]).toContain('deprecated');
+    expect(spy.mock.calls[0][0]).toContain('<<845-01-01,845-01-01>>');
+  });
+
+  it('renders the title as plain text in a legacy-xref span', () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const html = renderContent('See <<845-01-01, 845-01-01>> for details.');
+    expect(html).toContain('legacy-xref');
+    expect(html).toContain('845-01-01');
+    // Must NOT contain bib-ref or bib-link (the old wrong behavior)
+    expect(html).not.toContain('bib-ref');
+    expect(html).not.toContain('bib-link');
+  });
+
+  it('does NOT call bibResolver (cascade is not bypassed)', () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const bibResolver = vi.fn(() => '<a class="bib-link">mock</a>');
+    const opts: RenderOptions = { bibResolver };
+    const html = renderContent('<<845-01-01, 845-01-01>>', opts);
+    expect(bibResolver).not.toHaveBeenCalled();
+    expect(html).not.toContain('bib-link');
+  });
+
+  it('cleanContent extracts the title from <<ref,title>>', () => {
+    expect(cleanContent('See <<845-01-01, 845-01-01>>')).toContain('845-01-01');
+  });
+});

package/src/__tests__/validate-shacl.test.ts

@@ -4,7 +4,7 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const SCRIPT = join(__dirname, '..', '..', 'scripts', 'validate-shacl.mjs');
+const SCRIPT = join(__dirname, '..', '..', 'scripts', 'validate-shacl.ts');
 const FIXTURES = join(__dirname, '..', '__fixtures__', 'shacl');
 const SHAPES = join(__dirname, '..', '__fixtures__', 'concept-shape.ttl');
 
@@ -31,13 +31,13 @@ function execCaught(cmd: string, args: string[], opts: Parameters<typeof execFil
 }
 
 function runValidate(dataDir: string, { env, shapes }: RunOptions = {}): RunResult {
-  return execCaught('node', [SCRIPT, '--shapes', shapes ?? SHAPES, dataDir], {
+  return execCaught('node', ['--import', 'tsx', SCRIPT, '--shapes', shapes ?? SHAPES, dataDir], {
     env: { ...process.env, ...env },
   });
 }
 
 function runValidateRaw(args: string[], { env }: RunOptions = {}): RunResult {
-  return execCaught('node', [SCRIPT, ...args], {
+  return execCaught('node', ['--import', 'tsx', SCRIPT, ...args], {
     env: { ...process.env, ...env },
     stdio: ['ignore', 'pipe', 'pipe'],
   });

package/src/adapters/wire/index.ts

@@ -0,0 +1,69 @@
+/**
+ * Wire-format types barrel — single import path for all wire types.
+ *
+ * Three MECE layers:
+ *   - YAML author format (INPUT to build pipeline)
+ *   - JSON-LD browser format (OUTPUT of build pipeline)
+ *   - Manifest / site-config metadata
+ *
+ * Usage:
+ *   import type { HarmonizedConcept, JsonLdConcept, Manifest } from '@/adapters/wire'
+ *
+ * Or layer-specific:
+ *   import type { HarmonizedConcept } from '@/adapters/wire/yaml'
+ *   import type { JsonLdConcept } from '@/adapters/wire/jsonld'
+ */
+
+// YAML author format — what dataset authors write
+export type {
+  YamlContent,
+  YamlTerm,
+  YamlOrigin,
+  YamlGrammarInfo,
+  YamlSource,
+  YamlDate,
+  YamlRelation,
+  YamlPartitiveMember,
+  YamlPartitiveRelation,
+  YamlGenericRelation,
+  YamlLocalization,
+  HarmonizedConcept,
+  YamlManagedConceptDoc,
+  YamlManifestSection,
+  YamlManifest,
+  YamlBibliographyEntry,
+  YamlNewsFrontmatter,
+  YamlContentPage,
+  ShaclConstraint,
+  PrefixMap,
+} from '../../../scripts/lib/yaml-types';
+
+// JSON-LD browser format — what the SPA reads
+export type {
+  JsonLdContent,
+  JsonLdDate,
+  JsonLdPronunciation,
+  JsonLdGrammarInfo,
+  JsonLdRef,
+  JsonLdLocality,
+  JsonLdOrigin,
+  JsonLdSource,
+  JsonLdRelated,
+  JsonLdDesignation,
+  JsonLdLocalizedConcept,
+  JsonLdPartitiveMember,
+  JsonLdPartitiveRelation,
+  JsonLdConcept,
+} from '../jsonld-types';
+
+// Manifest + summary types
+export type {
+  Manifest,
+  ManifestSection,
+  ConceptSummary,
+  CitationClassification,
+  CiteResolution,
+} from '../types';
+
+// Wire-key constants (runtime value, not just type)
+export { GL } from '../wire-keys';

package/src/pages/[...path].astro

@@ -17,6 +17,7 @@ export async function getStaticPaths() {
     { params: { path: 'learn/relationships' } },
     { params: { path: 'learn/designations' } },
     { params: { path: 'learn/statuses' } },
+    { params: { path: 'learn/inline-content' } },
   ];
   for (const ds of datasets) {
     paths.push({ params: { path: `dataset/${ds.data.id}/about` } });

package/src/router/index.ts

@@ -118,6 +118,11 @@ export const routes: RouteRecordRaw[] = [
     name: 'learn-statuses',
     component: () => import('../views/learn/LearnStatusesView.vue'),
   },
+  {
+    path: '/learn/inline-content',
+    name: 'learn-inline-content',
+    component: () => import('../views/learn/LearnInlineContentView.vue'),
+  },
   {
     path: '/about',
     name: 'about-global',