@glossarist/concept-browser 0.7.66 → 0.7.67

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

@@ -1,246 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { computed, ref, nextTick } from 'vue';
-import { Concept } from 'glossarist';
-import { useRdfDocument } from '../../components/concept-rdf/use-rdf-document';
-import { RDF_PREFIXES, findPrefix } from '../../components/concept-rdf/rdf-prefixes';
-
-function makeConcept(): Concept {
-  return Concept.fromJSON({
-    id: '3.1.1',
-    uri: 'https://glossarist.org/test/concept/3.1.1',
-    status: 'valid',
-    localizations: {
-      eng: {
-        language_code: 'eng',
-        entry_status: 'valid',
-        terms: [
-          { type: 'expression', designation: 'atomic data unit', normative_status: 'preferred' },
-          { type: 'expression', designation: 'ADU', normative_status: 'admitted' },
-        ],
-        definition: [{ content: 'A data unit that cannot be subdivided.' }],
-        notes: [{ content: 'Note here.' }],
-      },
-    },
-  });
-}
-
-function makeConceptWithNonVerbal(): Concept {
-  return Concept.fromJSON({
-    id: '3.1.2',
-    uri: 'https://glossarist.org/test/concept/3.1.2',
-    status: 'valid',
-    localizations: {
-      eng: {
-        language_code: 'eng',
-        entry_status: 'valid',
-        terms: [{ type: 'expression', designation: 'angle of repose', normative_status: 'preferred' }],
-        definition: [{ content: 'Angle formed by a material at rest.' }],
-        non_verbal_rep: [
-          { type: 'figure', caption: 'Angle of repose diagram', description: 'Schematic diagram showing the angle', images: [{ src: 'fig_A.23.svg' }] },
-          { type: 'formula', caption: 'tan(θ) = μ' },
-        ],
-      },
-    },
-  });
-}
-
-describe('useRdfDocument — Turtle emission contract', () => {
-  it('declares skosxl: prefix and never xl:', () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).toContain('@prefix skosxl: <http://www.w3.org/2008/05/skos-xl#>');
-    expect(turtle.value).not.toContain('@prefix xl:');
-    expect(turtle.value).not.toMatch(/\bxl:/);
-  });
-
-  it('emits BOTH skosxl:prefLabel AND skos:prefLabel', () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).toMatch(/skosxl:prefLabel\s+<[^>]+\/eng\/desig\//);
-    expect(turtle.value).toMatch(/skos:prefLabel "atomic data unit"@eng/);
-  });
-
-  it('emits BOTH skosxl:altLabel AND skos:altLabel for admitted designations', () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).toMatch(/skosxl:altLabel\s+<[^>]+\/eng\/desig\//);
-    expect(turtle.value).toMatch(/skos:altLabel "ADU"@eng/);
-  });
-
-  it('emits skos:definition with language tag', () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).toMatch(/skos:definition "A data unit that cannot be subdivided\."@eng/);
-  });
-
-  it('emits gloss:hasDefinition as a typed gloss:DetailedDefinition with rdf:value', () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).toMatch(/gloss:hasDefinition \[ (a|rdf:type) gloss:DetailedDefinition ; rdf:value "[^"]+"@eng \]/);
-  });
-
-  it('terminates the concept resource with a full stop (not a trailing semicolon)', () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    const block = turtle.value.split('\n\n')[1] ?? '';
-    expect(block).toMatch(/<[^>]+> a gloss:Concept, skos:Concept ;[\s\S]+gloss:hasLocalization <[^>]+>/);
-    expect(block).toMatch(/\.$/);
-    expect(block).not.toMatch(/;\s*$/);
-  });
-
-  it('attaches provenance triples to the concept resource', () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).toMatch(/prov:wasGeneratedBy <activity\/serializers\/concept-browser\//);
-    expect(turtle.value).toMatch(/prov:generatedAtTime "[^"]+"\^\^xsd:dateTime/);
-  });
-});
-
-describe('useRdfDocument — JSON-LD emission contract', () => {
-  it('produces a parseable JSON-LD document with @context and @graph', () => {
-    const c = ref(makeConcept());
-    const { jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    const doc = JSON.parse(jsonld.value);
-    expect(doc['@context']).toBeDefined();
-    expect(Array.isArray(doc['@graph'])).toBe(true);
-    expect(doc['@context'].skosxl).toBe('http://www.w3.org/2008/05/skos-xl#');
-  });
-
-  it('emits the concept node and at least one localized concept', () => {
-    const c = ref(makeConcept());
-    const { jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    const doc = JSON.parse(jsonld.value);
-    const types = doc['@graph'].map((n: any) => n['@type']);
-    expect(types.some((t: any) => Array.isArray(t) && t.includes('gloss:Concept'))).toBe(true);
-    expect(types.some((t: any) => Array.isArray(t) && t.includes('gloss:LocalizedConcept'))).toBe(true);
-  });
-});
-
-describe('useRdfDocument — non-verbal representation emission (WS K)', () => {
-  it('emits gloss:hasNonVerbalRepresentation for NVR with caption (K4 URI form)', () => {
-    const c = ref(makeConceptWithNonVerbal());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).toMatch(/gloss:hasNonVerbalRepresentation <[^>]+\/nvr\/[^>]+>/);
-    expect(turtle.value).toMatch(/(a|rdf:type) gloss:NonVerbalRep/);
-    expect(turtle.value).toMatch(/skosxl:prefLabel \[/);
-  });
-
-  it('emits gloss:image as xsd:anyURI on the NVR resource', () => {
-    const c = ref(makeConceptWithNonVerbal());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).toMatch(/gloss:image "fig_A\.23\.svg"\^\^xsd:anyURI/);
-  });
-
-  it('emits NVR URIs in JSON-LD with NonVerbalRep type', () => {
-    const c = ref(makeConceptWithNonVerbal());
-    const { jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    const doc = JSON.parse(jsonld.value);
-    const nvrNodes = doc['@graph'].filter((n: any) => {
-      const t = n['@type'];
-      return Array.isArray(t) ? t.includes('gloss:NonVerbalRep') : t === 'gloss:NonVerbalRep';
-    });
-    expect(nvrNodes.length).toBeGreaterThanOrEqual(1);
-    const lcNode = doc['@graph'].find((n: any) => Array.isArray(n['@type']) && n['@type'].includes('gloss:LocalizedConcept'));
-    expect(lcNode).toBeDefined();
-    const refRaw = lcNode['gloss:hasNonVerbalRepresentation'];
-    const refArr = Array.isArray(refRaw) ? refRaw : [refRaw];
-    expect(refArr.length).toBeGreaterThanOrEqual(1);
-    expect(refArr[0]['@id']).toMatch(/\/nvr\/[^/]+$/);
-  });
-
-  it('includes non-verbal reps in the sections view', () => {
-    const c = ref(makeConceptWithNonVerbal());
-    const { sections } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    const lcSection = sections.value.find(s => s.classId === 'gloss:LocalizedConcept');
-    expect(lcSection).toBeDefined();
-    const nvrProps = lcSection!.props.filter(p =>
-      p.predicate === 'gloss:hasNonVerbalRepresentation' || p.predicate === 'gloss:hasNonVerbalRep',
-    );
-    expect(nvrProps.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('omits non-verbal emission when the concept has no non-verbal reps', () => {
-    const c = ref(makeConcept());
-    const { turtle, jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(turtle.value).not.toMatch(/gloss:hasNonVerbalRep/);
-    expect(turtle.value).not.toMatch(/gloss:hasNonVerbalRepresentation/);
-    const doc = JSON.parse(jsonld.value);
-    const lcNode = doc['@graph'].find((n: any) => Array.isArray(n['@type']) && n['@type'].includes('gloss:LocalizedConcept'));
-    expect(lcNode['gloss:hasNonVerbalRep']).toBeUndefined();
-  });
-});
-
-describe('useRdfDocument — reactivity', () => {
-  it('recomputes turtle when the concept changes', async () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    const before = turtle.value;
-    expect(before).toContain('atomic data unit');
-
-    const next = Concept.fromJSON({
-      id: '4.5.6',
-      uri: 'https://glossarist.org/test/concept/4.5.6',
-      status: 'valid',
-      localizations: {
-        eng: {
-          language_code: 'eng',
-          entry_status: 'valid',
-          terms: [{ type: 'expression', designation: 'different designation', normative_status: 'preferred' }],
-          definition: [{ content: 'Different definition.' }],
-        },
-      },
-    });
-    c.value = next;
-    await nextTick();
-    expect(turtle.value).not.toBe(before);
-    expect(turtle.value).toContain('different designation');
-  });
-
-  it('returns one section per concept + localized concept + designation', () => {
-    const c = ref(makeConcept());
-    const { sections } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    const labels = sections.value.map(s => s.classId);
-    expect(labels).toContain('gloss:Concept');
-    expect(labels).toContain('gloss:LocalizedConcept');
-    expect(labels.filter(l => l === 'gloss:Expression').length).toBe(2);
-  });
-
-  it('emits a type chain ending in gloss:Concept', () => {
-    const c = ref(makeConcept());
-    const { typeChain } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    expect(typeChain.value[typeChain.value.length - 1]).toBe('gloss:Concept');
-  });
-
-  it('can be consumed inside another computed without re-triggering the emitter', () => {
-    const c = ref(makeConcept());
-    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
-    const upper = computed(() => turtle.value.split('\n').length);
-    const initial = upper.value;
-    expect(initial).toBeGreaterThan(5);
-    // No mutation: reading upper twice doesn't recompute turtle.
-    expect(upper.value).toBe(initial);
-  });
-});
-
-describe('rdf-prefixes legend', () => {
-  it('declares all canonical prefixes used by the emitter', () => {
-    const declared = new Set(RDF_PREFIXES.map(p => p.prefix));
-    for (const required of ['gloss', 'skos', 'skosxl', 'rdf', 'dcterms']) {
-      expect(declared.has(required)).toBe(true);
-    }
-  });
-
-  it('lookup returns the matching prefix entry', () => {
-    expect(findPrefix('skosxl')?.iri).toBe('http://www.w3.org/2008/05/skos-xl#');
-  });
-
-  it('returns undefined for unknown prefixes', () => {
-    expect(findPrefix('does-not-exist')).toBeUndefined();
-  });
-
-  it('skosxl prefix resolves to the canonical IRI (settlement decision)', () => {
-    const skosxl = findPrefix('skosxl');
-    expect(skosxl).toBeDefined();
-    expect(skosxl!.iri).toBe('http://www.w3.org/2008/05/skos-xl#');
-  });
-});

package/src/__tests__/concept-rdf/version-emitter.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Parser, Store } from 'n3';
-import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
-import { emitVersionGraph, emitVersionHistory } from '../../components/concept-rdf/version-emitter';
-
-const PROV = 'http://www.w3.org/ns/prov#';
-const DCTERMS = 'http://purl.org/dc/terms/';
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
-
-function parse(turtle: string): Store {
-  const parser = new Parser({ format: 'Turtle' });
-  const store = new Store();
-  store.addQuads(parser.parse(turtle));
-  return store;
-}
-
-const VERSION_IRI = 'https://glossarist.org/test/versions/1.0';
-
-function makeInput() {
-  return {
-    registerId: 'test',
-    version: '1.0',
-    versionIri: VERSION_IRI,
-    datasetIri: 'https://glossarist.org/test/',
-    generatedAt: '2026-06-28T12:00:00Z',
-  };
-}
-
-describe('emitVersionGraph — J6 dataset versioning', () => {
-  it('types the version as prov:Entity', () => {
-    const graph = emitVersionGraph(makeInput());
-    const store = parse(writeTurtle(graph));
-    const types = store.getObjects(VERSION_IRI, RDF_TYPE, null).map(q => q.value);
-    expect(types).toContain(`${PROV}Entity`);
-  });
-
-  it('emits dcterms:isVersionOf pointing at the canonical dataset IRI', () => {
-    const graph = emitVersionGraph(makeInput());
-    const store = parse(writeTurtle(graph));
-    const targets = store.getObjects(VERSION_IRI, `${DCTERMS}isVersionOf`, null).map(q => q.value);
-    expect(targets).toContain('https://glossarist.org/test/');
-  });
-
-  it('emits prov:generatedAtTime as xsd:dateTime', () => {
-    const graph = emitVersionGraph(makeInput());
-    const store = parse(writeTurtle(graph));
-    const ts = store.getObjects(VERSION_IRI, `${PROV}generatedAtTime`, null).map(q => q.value);
-    expect(ts).toContain('2026-06-28T12:00:00Z');
-  });
-
-  it('emits prov:wasRevisionOf when a previous version is provided', () => {
-    const graph = emitVersionGraph({ ...makeInput(), previousVersionIri: 'https://glossarist.org/test/versions/0.9' });
-    const store = parse(writeTurtle(graph));
-    const prev = store.getObjects(VERSION_IRI, `${PROV}wasRevisionOf`, null).map(q => q.value);
-    expect(prev).toContain('https://glossarist.org/test/versions/0.9');
-  });
-
-  it('omits prov:wasRevisionOf when no previous version', () => {
-    const graph = emitVersionGraph(makeInput());
-    const store = parse(writeTurtle(graph));
-    const prev = store.getObjects(VERSION_IRI, `${PROV}wasRevisionOf`, null);
-    expect(prev).toHaveLength(0);
-  });
-
-  it('records change summary and associated agent when provided', () => {
-    const graph = emitVersionGraph({
-      ...makeInput(),
-      changeSummary: 'Initial release',
-      associatedAgentIri: 'https://glossarist.org/agent/ci-bot',
-    });
-    const store = parse(writeTurtle(graph));
-    const summaries = store.getObjects(VERSION_IRI, `${DCTERMS}description`, null).map(q => q.value);
-    expect(summaries).toContain('Initial release');
-    const agents = store.getObjects(VERSION_IRI, `${PROV}wasAssociatedWith`, null).map(q => q.value);
-    expect(agents).toContain('https://glossarist.org/agent/ci-bot');
-  });
-});
-
-describe('emitVersionHistory', () => {
-  it('emits a chain of versions with prov:wasRevisionOf links', () => {
-    const graph = emitVersionHistory({
-      registerId: 'test',
-      datasetIri: 'https://glossarist.org/test/',
-      versions: [
-        { version: '1.0', generatedAt: '2024-01-01T00:00:00Z' },
-        { version: '1.1', generatedAt: '2024-06-01T00:00:00Z', changeSummary: 'Add 50 terms' },
-        { version: '2.0', generatedAt: '2025-01-01T00:00:00Z', changeSummary: 'Major release' },
-      ],
-      associatedAgentIri: 'https://glossarist.org/agent/ci-bot',
-    });
-
-    const store = parse(writeTurtle(graph));
-    const iri10 = 'https://glossarist.org/test/versions/1.0';
-    const iri11 = 'https://glossarist.org/test/versions/1.1';
-    const iri20 = 'https://glossarist.org/test/versions/2.0';
-
-    expect(store.getObjects(iri10, RDF_TYPE, null).length).toBeGreaterThan(0);
-    expect(store.getObjects(iri11, RDF_TYPE, null).length).toBeGreaterThan(0);
-    expect(store.getObjects(iri20, RDF_TYPE, null).length).toBeGreaterThan(0);
-
-    const v11Prev = store.getObjects(iri11, `${PROV}wasRevisionOf`, null).map(q => q.value);
-    expect(v11Prev).toContain(iri10);
-
-    const v20Prev = store.getObjects(iri20, `${PROV}wasRevisionOf`, null).map(q => q.value);
-    expect(v20Prev).toContain(iri11);
-
-    const v10Prev = store.getObjects(iri10, `${PROV}wasRevisionOf`, null);
-    expect(v10Prev).toHaveLength(0);
-  });
-
-  it('emits an empty graph when versions array is empty', () => {
-    const graph = emitVersionHistory({
-      registerId: 'test',
-      datasetIri: 'https://glossarist.org/test/',
-      versions: [],
-    });
-    const resources = Array.from(graph.resources());
-    expect(resources.length).toBe(0);
-  });
-});

package/src/__tests__/concept-rdf/vocabulary-ssot.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { Parser, Store } from 'n3';
-import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
-import { emitVocabularyGraph, VOCAB_SCHEMES } from '../../components/concept-rdf/vocabulary-emitter';
-
-const VOCAB_JSON = JSON.parse(readFileSync(join(process.cwd(), 'data', 'glossarist-vocab.json'), 'utf8'));
-
-function parse(turtle: string): Store {
-  const parser = new Parser({ format: 'Turtle' });
-  const store = new Store();
-  store.addQuads(parser.parse(turtle));
-  return store;
-}
-
-const SKOS = 'http://www.w3.org/2004/02/skos/core#';
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
-
-const EXPECTED_REL_TYPES = [
-  'deprecates', 'deprecated_by', 'supersedes', 'superseded_by', 'replaces', 'replaced_by',
-  'invalidates', 'invalidated_by', 'retires', 'retired_by',
-  'narrower', 'broader', 'broader_generic', 'narrower_generic',
-  'broader_partitive', 'narrower_partitive', 'has_part', 'is_part_of',
-  'broader_instantial', 'narrower_instantial', 'instance_of', 'has_instance',
-  'equivalent', 'exact_match', 'close_match', 'broad_match', 'narrow_match', 'related_match',
-  'compare', 'contrast',
-  'see', 'references', 'related_concept', 'related_concept_broader', 'related_concept_narrower',
-  'sequentially_related', 'spatially_related', 'temporally_related',
-  'homograph', 'false_friend',
-  'has_concept', 'is_concept_of', 'has_definition', 'definition_of',
-  'inherits', 'inherited_by',
-  'has_version', 'version_of', 'current_version', 'current_version_of',
-  'derived',
-];
-
-describe('A1/A2/C1 — vocabulary SSOT', () => {
-  it('VOCAB_SCHEMES loads from data/glossarist-vocab.json at module init', () => {
-    expect(VOCAB_SCHEMES.length).toBe(VOCAB_JSON.schemes.length);
-  });
-
-  it('every scheme entry in JSON appears in VOCAB_SCHEMES', () => {
-    const expected = new Set(VOCAB_JSON.schemes.map((s: any) => s.schemeIri));
-    const actual = new Set(VOCAB_SCHEMES.map(s => s.schemeIri));
-    expect(actual).toEqual(expected);
-  });
-
-  it('TS and mjs consumers read the same JSON file (single source of truth)', () => {
-    const tsCount = VOCAB_SCHEMES.reduce((acc, s) => acc + s.terms.length, 0);
-    const jsonCount = VOCAB_JSON.schemes.reduce(
-      (acc: number, s: any) => acc + s.terms.length, 0,
-    );
-    expect(tsCount).toBe(jsonCount);
-  });
-});
-
-describe('C1 — all 52 relationship types are declared', () => {
-  it('relationship-type scheme declares every type in EXPECTED_REL_TYPES', () => {
-    const relScheme = VOCAB_SCHEMES.find(s => s.schemeIri === 'gloss:rel-scheme');
-    expect(relScheme).toBeDefined();
-    const declared = new Set(relScheme!.terms.map(t => t.label));
-    for (const expected of EXPECTED_REL_TYPES) {
-      expect(declared.has(expected)).toBe(true);
-    }
-  });
-
-  it('relationship-type count matches glossarist-ruby config.yml (50 canonical + legacy)', () => {
-    const relScheme = VOCAB_SCHEMES.find(s => s.schemeIri === 'gloss:rel-scheme');
-    // glossarist-ruby config.yml related_concept.type lists 50 types. We add 'derived' as a legacy alias.
-    expect(relScheme!.terms.length).toBeGreaterThanOrEqual(50);
-  });
-
-  it('every relationship type IRI follows the gloss:rel/{type} pattern', () => {
-    const relScheme = VOCAB_SCHEMES.find(s => s.schemeIri === 'gloss:rel-scheme');
-    for (const term of relScheme!.terms) {
-      expect(term.iri).toMatch(/^gloss:rel\/[a-z_]+$/);
-    }
-  });
-
-  it('every relationship type is a skos:Concept in the emitted graph', () => {
-    const ttl = writeTurtle(emitVocabularyGraph());
-    const store = parse(ttl);
-    for (const term of VOCAB_SCHEMES.find(s => s.schemeIri === 'gloss:rel-scheme')!.terms) {
-      const iri = `https://www.glossarist.org/ontologies/rel/${term.label}`;
-      const types = store.getObjects(iri, RDF_TYPE, null).map(q => q.value);
-      expect(types).toContain(`${SKOS}Concept`);
-    }
-  });
-});
-
-describe('C1 — vocabulary emits without drift between TS and mjs', () => {
-  it('emitted Turtle contains every scheme and every term', () => {
-    const ttl = writeTurtle(emitVocabularyGraph());
-    for (const scheme of VOCAB_SCHEMES) {
-      for (const term of scheme.terms) {
-        expect(ttl).toContain(term.label);
-      }
-    }
-  });
-});

package/src/__tests__/perf/bundle-layout.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const DIST_DIR = 'dist';
-const ASSETS_DIR = join(DIST_DIR, 'assets');
-
-function distExists(): boolean {
-  return existsSync(ASSETS_DIR);
-}
-
-function readAsset(name: string): string {
-  return readFileSync(join(ASSETS_DIR, name), 'utf8');
-}
-
-function listJsAssets(): string[] {
-  return readdirSync(ASSETS_DIR).filter(f => f.endsWith('.js'));
-}
-
-const MAIN_CHUNK_RE = /^index-[^/]*\.js$/;
-const CONCEPT_CHUNK_RE = /^ConceptView-[^/]*\.js$/;
-
-describe.skipIf(!distExists())('bundle: RDF serializer stays out of main chunk', () => {
-  it('the main index-* chunk does not embed the RDF emitter', () => {
-    const mainChunks = listJsAssets().filter(f => MAIN_CHUNK_RE.test(f));
-    expect(mainChunks.length).toBeGreaterThan(0);
-
-    for (const chunk of mainChunks) {
-      const text = readAsset(chunk);
-      expect(text, `${chunk} should not embed use-rdf-document`).not.toMatch(/use-rdf-document/);
-      expect(text, `${chunk} should not emit skosxl:literalForm literals`).not.toMatch(/skosxl:literalForm/);
-    }
-  });
-
-  it('the ConceptView chunk DOES contain the RDF emitter', () => {
-    const conceptChunks = listJsAssets().filter(f => CONCEPT_CHUNK_RE.test(f));
-    expect(conceptChunks.length).toBeGreaterThan(0);
-
-    const merged = conceptChunks.map(readAsset).join('\n');
-    expect(merged).toMatch(/skosxl:literalForm/);
-  });
-
-  it('no chunk emits the legacy `xl:` prefix', () => {
-    for (const chunk of listJsAssets()) {
-      const text = readAsset(chunk);
-      expect(text, `${chunk} should not contain the legacy xl: prefix`).not.toMatch(/\bxl:prefLabel/);
-      expect(text, `${chunk} should not contain the legacy xl:altLabel/`).not.toMatch(/\bxl:altLabel/);
-    }
-  });
-});

package/src/components/concept-rdf/agents-emitter.ts

@@ -1,82 +0,0 @@
-import { FOAF, PROV, DCTERMS, RDFS } from './predicates';
-import { RdfGraph } from './rdf-graph';
-
-export interface AgentInput {
-  readonly slug: string;
-  readonly name: string;
-  readonly role?: string;
-  readonly organization?: string;
-  readonly url?: string;
-  readonly email?: string;
-  readonly agentIri: string;
-}
-
-export interface AgentEmissionResult {
-  readonly graph: RdfGraph;
-  readonly personIris: readonly string[];
-  readonly organizationIris: readonly string[];
-}
-
-function slugify(input: string): string {
-  return input
-    .toLowerCase()
-    .normalize('NFKD')
-    .replace(/[̀-ͯ]/g, '')
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}
-
-export function agentsFromContributors(
-  contributors: readonly { name: string; role?: string; organization?: string; url?: string; email?: string }[],
-  agentBase = 'https://glossarist.org/agent',
-): readonly AgentInput[] {
-  return contributors.map(c => ({
-    slug: slugify(c.name),
-    name: c.name,
-    role: c.role,
-    organization: c.organization,
-    url: c.url,
-    email: c.email,
-    agentIri: `${agentBase}/${slugify(c.name)}`,
-  }));
-}
-
-export function emitAgentsGraph(agents: readonly AgentInput[]): AgentEmissionResult {
-  const graph = new RdfGraph();
-  const personIris: string[] = [];
-  const orgSlugs = new Set<string>();
-  const organizationIris: string[] = [];
-
-  for (const a of agents) {
-    const w = graph.declare(a.agentIri, {
-      types: [FOAF.Person, PROV.Person, PROV.Agent],
-      label: a.name,
-      classLabel: 'Person',
-      classId: FOAF.Person,
-    });
-    w.literal(FOAF.name, a.name);
-    if (a.email) w.iri(FOAF.mbox, `mailto:${a.email}`);
-    if (a.url) w.iri(RDFS.seeAlso, a.url);
-    if (a.role) w.literal(DCTERMS.description, a.role);
-    personIris.push(a.agentIri);
-
-    if (a.organization) {
-      const orgSlug = slugify(a.organization);
-      const orgIri = `https://glossarist.org/org/${orgSlug}`;
-      w.iri(PROV.actedOnBehalfOf, orgIri);
-      if (!orgSlugs.has(orgSlug)) {
-        orgSlugs.add(orgSlug);
-        const orgW = graph.declare(orgIri, {
-          types: [FOAF.Organization, PROV.Organization, PROV.Agent],
-          label: a.organization,
-          classLabel: 'Organization',
-          classId: FOAF.Organization,
-        });
-        orgW.literal(FOAF.name, a.organization);
-        organizationIris.push(orgIri);
-      }
-    }
-  }
-
-  return { graph, personIris, organizationIris };
-}

package/src/components/concept-rdf/bibliography-emitter.ts

@@ -1,83 +0,0 @@
-import { DCTERMS, FOAF, RDF } from './predicates';
-import { RdfGraph } from './rdf-graph';
-
-export interface BibliographyEntry {
-  readonly id: string;
-  readonly reference: string;
-  readonly title?: string;
-  readonly link?: string;
-  readonly type?: string;
-}
-
-export interface BibliographyInput {
-  readonly registerId: string;
-  readonly entries: readonly BibliographyEntry[];
-  readonly baseUri?: string;
-}
-
-type BibliographyDataShape =
-  | { [id: string]: BibliographyEntryLike }
-  | { bibliography: readonly BibliographyEntryLike[] };
-
-interface BibliographyEntryLike {
-  readonly id?: string;
-  readonly reference?: string;
-  readonly title?: string;
-  readonly link?: string;
-  readonly type?: string;
-}
-
-export function bibliographyEntryIri(registerId: string, id: string, baseUri = 'https://glossarist.org'): string {
-  return `${baseUri}/${registerId}/bib/${id}`;
-}
-
-export function normalizeBibliographyData(raw: unknown): readonly BibliographyEntry[] {
-  if (!raw || typeof raw !== 'object') return [];
-  const obj = raw as Record<string, unknown>;
-
-  if (Array.isArray(obj.bibliography)) {
-    return (obj.bibliography as readonly BibliographyEntryLike[]).map(e => entryFromV3(e));
-  }
-
-  const entries: BibliographyEntry[] = [];
-  for (const [id, value] of Object.entries(obj)) {
-    if (!value || typeof value !== 'object') continue;
-    const entry = entryFromV3(value as BibliographyEntryLike, id);
-    entries.push(entry);
-  }
-  return entries;
-}
-
-function entryFromV3(e: BibliographyEntryLike, fallbackId?: string): BibliographyEntry {
-  const id = e.id ?? fallbackId ?? '';
-  const reference = e.reference ?? '';
-  return {
-    id,
-    reference,
-    title: e.title,
-    link: e.link,
-    type: e.type,
-  };
-}
-
-export function emitBibliographyGraph(input: BibliographyInput): RdfGraph {
-  const baseUri = input.baseUri ?? 'https://glossarist.org';
-  const graph = new RdfGraph();
-  for (const entry of input.entries) {
-    if (!entry.id || !entry.reference) continue;
-    const iri = bibliographyEntryIri(input.registerId, entry.id, baseUri);
-    const w = graph.declare(iri, {
-      types: ['dcterms:BibliographicResource'],
-      label: entry.title ?? entry.reference,
-      classLabel: 'BibliographicResource',
-      classId: 'dcterms:BibliographicResource',
-    });
-    w.literal(DCTERMS.identifier, entry.id);
-    w.literal(DCTERMS.bibliographicCitation, entry.reference);
-    if (entry.title) w.literal(DCTERMS.title, entry.title);
-    if (entry.link) w.iri(FOAF.page, entry.link);
-    if (entry.type) w.iri(DCTERMS.type, `gloss:bibtype/${entry.type}`);
-    w.iri(DCTERMS.isPartOf, `${baseUri}/${input.registerId}/`);
-  }
-  return graph;
-}