@glossarist/concept-browser 0.7.66 → 0.7.67

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

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Parser, Store } from 'n3';
-import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
-import {
-  agentsFromContributors,
-  emitAgentsGraph,
-} from '../../components/concept-rdf/agents-emitter';
-
-const FOAF = 'http://xmlns.com/foaf/0.1/';
-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;
-}
-
-describe('agentsFromContributors', () => {
-  it('turns each contributor into an AgentInput with a slugified IRI', () => {
-    const agents = agentsFromContributors([
-      { name: 'Ada Lovelace', role: 'Editor', organization: 'Royal Society', email: 'ada@example.org' },
-      { name: 'Grace Hopper', organization: 'USN' },
-    ]);
-    expect(agents.length).toBe(2);
-    expect(agents[0].agentIri).toBe('https://glossarist.org/agent/ada-lovelace');
-    expect(agents[1].agentIri).toBe('https://glossarist.org/agent/grace-hopper');
-    expect(agents[0].role).toBe('Editor');
-  });
-
-  it('deduplicates organizations by slug', () => {
-    const result = emitAgentsGraph(agentsFromContributors([
-      { name: 'Alice', organization: 'ISO' },
-      { name: 'Bob',   organization: 'ISO' },
-      { name: 'Carol', organization: 'IEC' },
-    ]));
-    expect(result.organizationIris.length).toBe(2);
-  });
-});
-
-describe('emitAgentsGraph — J4 agent records', () => {
-  it('types each person as foaf:Person, prov:Person, prov:Agent', () => {
-    const graph = emitAgentsGraph(agentsFromContributors([
-      { name: 'Ada Lovelace', email: 'ada@example.org' },
-    ]));
-    const store = parse(writeTurtle(graph.graph));
-    const types = store.getObjects('https://glossarist.org/agent/ada-lovelace', RDF_TYPE, null).map(q => q.value);
-    expect(types).toContain(`${FOAF}Person`);
-    expect(types).toContain(`${PROV}Person`);
-    expect(types).toContain(`${PROV}Agent`);
-  });
-
-  it('records name, email (as mailto IRI), role, and url', () => {
-    const graph = emitAgentsGraph(agentsFromContributors([
-      { name: 'Ada Lovelace', role: 'Editor', email: 'ada@example.org', url: 'https://example.org/ada' },
-    ]));
-    const store = parse(writeTurtle(graph.graph));
-    const names = store.getObjects('https://glossarist.org/agent/ada-lovelace', `${FOAF}name`, null).map(q => q.value);
-    expect(names).toContain('Ada Lovelace');
-
-    const mboxes = store.getObjects('https://glossarist.org/agent/ada-lovelace', `${FOAF}mbox`, null).map(q => q.value);
-    expect(mboxes).toContain('mailto:ada@example.org');
-
-    const roles = store.getObjects('https://glossarist.org/agent/ada-lovelace', `${DCTERMS}description`, null).map(q => q.value);
-    expect(roles).toContain('Editor');
-
-    const seeAlso = store.getObjects('https://glossarist.org/agent/ada-lovelace', 'http://www.w3.org/2000/01/rdf-schema#seeAlso', null).map(q => q.value);
-    expect(seeAlso).toContain('https://example.org/ada');
-  });
-
-  it('creates a single prov:Organization per unique organization', () => {
-    const result = emitAgentsGraph(agentsFromContributors([
-      { name: 'Alice', organization: 'ISO' },
-      { name: 'Bob',   organization: 'ISO' },
-    ]));
-    expect(result.organizationIris).toEqual(['https://glossarist.org/org/iso']);
-
-    const store = parse(writeTurtle(result.graph));
-    const types = store.getObjects('https://glossarist.org/org/iso', RDF_TYPE, null).map(q => q.value);
-    expect(types).toContain(`${FOAF}Organization`);
-    expect(types).toContain(`${PROV}Organization`);
-    expect(types).toContain(`${PROV}Agent`);
-
-    const names = store.getObjects('https://glossarist.org/org/iso', `${FOAF}name`, null).map(q => q.value);
-    expect(names).toContain('ISO');
-  });
-
-  it('links every person to their organization via prov:actedOnBehalfOf', () => {
-    const result = emitAgentsGraph(agentsFromContributors([
-      { name: 'Alice', organization: 'ISO' },
-      { name: 'Bob',   organization: 'IEC' },
-    ]));
-    const store = parse(writeTurtle(result.graph));
-    const aliceOrg = store.getObjects('https://glossarist.org/agent/alice', `${PROV}actedOnBehalfOf`, null).map(q => q.value);
-    expect(aliceOrg).toContain('https://glossarist.org/org/iso');
-    const bobOrg = store.getObjects('https://glossarist.org/agent/bob', `${PROV}actedOnBehalfOf`, null).map(q => q.value);
-    expect(bobOrg).toContain('https://glossarist.org/org/iec');
-  });
-
-  it('omits mbox, seeAlso, and actedOnBehalfOf when not provided', () => {
-    const graph = emitAgentsGraph(agentsFromContributors([{ name: 'Solo' }]));
-    const store = parse(writeTurtle(graph.graph));
-    const mbox = store.getObjects('https://glossarist.org/agent/solo', `${FOAF}mbox`, null);
-    expect(mbox).toHaveLength(0);
-    const acted = store.getObjects('https://glossarist.org/agent/solo', `${PROV}actedOnBehalfOf`, null);
-    expect(acted).toHaveLength(0);
-  });
-});

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

@@ -1,159 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Parser, Store } from 'n3';
-import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
-import {
-  emitBibliographyGraph,
-  bibliographyEntryIri,
-  normalizeBibliographyData,
-} from '../../components/concept-rdf/bibliography-emitter';
-
-const FOAF = 'http://xmlns.com/foaf/0.1/';
-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;
-}
-
-describe('emitBibliographyGraph — K5 bibliography graph', () => {
-  it('types each entry as dcterms:BibliographicResource', () => {
-    const graph = emitBibliographyGraph({
-      registerId: 'iso-geodetic',
-      entries: [{ id: 'iso-704', reference: 'ISO 704' }],
-    });
-    const store = parse(writeTurtle(graph));
-    const iri = bibliographyEntryIri('iso-geodetic', 'iso-704');
-    const types = store.getObjects(iri, RDF_TYPE, null).map(q => q.value);
-    expect(types).toContain(`${DCTERMS}BibliographicResource`);
-  });
-
-  it('emits identifier, bibliographicCitation, and title as literals', () => {
-    const graph = emitBibliographyGraph({
-      registerId: 'iso-geodetic',
-      entries: [
-        { id: 'iso-704', reference: 'ISO 704', title: 'Terminology work — Principles and methods' },
-      ],
-    });
-    const store = parse(writeTurtle(graph));
-    const iri = bibliographyEntryIri('iso-geodetic', 'iso-704');
-    const ids = store.getObjects(iri, `${DCTERMS}identifier`, null).map(q => q.value);
-    expect(ids).toContain('iso-704');
-    const cites = store.getObjects(iri, `${DCTERMS}bibliographicCitation`, null).map(q => q.value);
-    expect(cites).toContain('ISO 704');
-    const titles = store.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value);
-    expect(titles).toContain('Terminology work — Principles and methods');
-  });
-
-  it('emits foaf:page when link is provided', () => {
-    const graph = emitBibliographyGraph({
-      registerId: 'iso-geodetic',
-      entries: [{ id: 'ref', reference: 'X', link: 'https://example.org/x' }],
-    });
-    const store = parse(writeTurtle(graph));
-    const iri = bibliographyEntryIri('iso-geodetic', 'ref');
-    const pages = store.getObjects(iri, `${FOAF}page`, null).map(q => q.value);
-    expect(pages).toContain('https://example.org/x');
-  });
-
-  it('omits foaf:page when link is absent', () => {
-    const graph = emitBibliographyGraph({
-      registerId: 'iso-geodetic',
-      entries: [{ id: 'no-link', reference: 'Y' }],
-    });
-    const store = parse(writeTurtle(graph));
-    const iri = bibliographyEntryIri('iso-geodetic', 'no-link');
-    const pages = store.getObjects(iri, `${FOAF}page`, null);
-    expect(pages).toHaveLength(0);
-  });
-
-  it('emits one resource per entry', () => {
-    const graph = emitBibliographyGraph({
-      registerId: 'iso-geodetic',
-      entries: [
-        { id: 'a', reference: 'A' },
-        { id: 'b', reference: 'B' },
-        { id: 'c', reference: 'C' },
-      ],
-    });
-    const iriA = bibliographyEntryIri('iso-geodetic', 'a');
-    const iriB = bibliographyEntryIri('iso-geodetic', 'b');
-    const iriC = bibliographyEntryIri('iso-geodetic', 'c');
-    const store = parse(writeTurtle(graph));
-    expect(store.getObjects(iriA, `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('A');
-    expect(store.getObjects(iriB, `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('B');
-    expect(store.getObjects(iriC, `${DCTERMS}bibliographicCitation`, null).map(q => q.value)).toContain('C');
-  });
-
-  it('links each entry to the dataset via dcterms:isPartOf', () => {
-    const graph = emitBibliographyGraph({
-      registerId: 'iso-geodetic',
-      entries: [{ id: 'a', reference: 'A' }],
-    });
-    const store = parse(writeTurtle(graph));
-    const iri = bibliographyEntryIri('iso-geodetic', 'a');
-    const parts = store.getObjects(iri, `${DCTERMS}isPartOf`, null).map(q => q.value);
-    expect(parts).toContain('https://glossarist.org/iso-geodetic/');
-  });
-});
-
-describe('B3/C — V3 bibliography shape (wrapper key)', () => {
-  it('normalizeBibliographyData unwraps { bibliography: [...] } V3 shape', () => {
-    const v3 = {
-      bibliography: [
-        { id: 'iso704', reference: 'ISO 704', title: 'Terminology work', type: 'normative' },
-        { id: 'iso10241', reference: 'ISO 10241-1' },
-      ],
-    };
-    const entries = normalizeBibliographyData(v3);
-    expect(entries.length).toBe(2);
-    expect(entries[0].id).toBe('iso704');
-    expect(entries[0].type).toBe('normative');
-    expect(entries[1].id).toBe('iso10241');
-  });
-
-  it('normalizeBibliographyData accepts the legacy flat-map shape', () => {
-    const legacy = {
-      iso704: { reference: 'ISO 704', title: 'Terminology work' },
-      iso10241: { reference: 'ISO 10241-1' },
-    };
-    const entries = normalizeBibliographyData(legacy);
-    expect(entries.length).toBe(2);
-    expect(entries.find(e => e.id === 'iso704')?.title).toBe('Terminology work');
-  });
-
-  it('emitBibliographyGraph handles both V3 and legacy shapes identically', () => {
-    const v3 = { bibliography: [{ id: 'iso704', reference: 'ISO 704', title: 'T' }] };
-    const legacy = { iso704: { reference: 'ISO 704', title: 'T' } };
-
-    const graphV3 = emitBibliographyGraph({
-      registerId: 'r',
-      entries: normalizeBibliographyData(v3),
-    });
-    const graphLegacy = emitBibliographyGraph({
-      registerId: 'r',
-      entries: normalizeBibliographyData(legacy),
-    });
-
-    const storeV3 = parse(writeTurtle(graphV3));
-    const storeLegacy = parse(writeTurtle(graphLegacy));
-
-    const iri = bibliographyEntryIri('r', 'iso704');
-    const v3Titles = storeV3.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value);
-    const legacyTitles = storeLegacy.getObjects(iri, `${DCTERMS}title`, null).map(q => q.value);
-    expect(v3Titles).toEqual(legacyTitles);
-  });
-
-  it('emits dcterms:type when entry.type is provided', () => {
-    const graph = emitBibliographyGraph({
-      registerId: 'r',
-      entries: [{ id: 'a', reference: 'X', type: 'normative' }],
-    });
-    const store = parse(writeTurtle(graph));
-    const iri = bibliographyEntryIri('r', 'a');
-    const types = store.getObjects(iri, `${DCTERMS}type`, null).map(q => q.value);
-    expect(types.some(t => t.includes('bibtype/normative'))).toBe(true);
-  });
-});

package/src/__tests__/concept-rdf/build-activity-emitter.test.ts

@@ -1,119 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Parser, Store } from 'n3';
-import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
-import { emitBuildActivityGraph, activityIri } from '../../components/concept-rdf/build-activity-emitter';
-import type { BuildActivityInput } from '../../components/concept-rdf/build-activity-emitter';
-
-function makeInput(overrides: Partial<BuildActivityInput> = {}): BuildActivityInput {
-  return {
-    runId: '2026-06-28T12-00-00Z',
-    startedAt: '2026-06-28T12:00:00Z',
-    endedAt: '2026-06-28T12:05:00Z',
-    gitSha: 'abc1234',
-    gitBranch: 'main',
-    toolId: 'concept-browser',
-    toolVersion: '0.7.51',
-    datasetRegisters: ['iso-geodetic', 'iso-10303-2-terms'],
-    conceptCount: 1234,
-    associatedAgentIri: 'https://glossarist.org/agent/ci-bot',
-    ...overrides,
-  };
-}
-
-function parse(turtle: string): Store {
-  const parser = new Parser({ format: 'Turtle' });
-  const store = new Store();
-  store.addQuads(parser.parse(turtle));
-  return store;
-}
-
-const expand = (v: string): string => {
-  if (v.startsWith('prov:'))    return `http://www.w3.org/ns/prov#${v.slice(5)}`;
-  if (v.startsWith('dcterms:')) return `http://purl.org/dc/terms/${v.slice(8)}`;
-  if (v.startsWith('rdf:'))     return `http://www.w3.org/1999/02/22-rdf-syntax-ns#${v.slice(4)}`;
-  if (v.startsWith('xsd:'))     return `http://www.w3.org/2001/XMLSchema#${v.slice(4)}`;
-  if (v.startsWith('foaf:'))    return `http://xmlns.com/foaf/0.1/${v.slice(5)}`;
-  return v;
-};
-
-describe('emitBuildActivityGraph — J7 build activity records', () => {
-  it('types the activity as prov:Activity', () => {
-    const input = makeInput();
-    const graph = emitBuildActivityGraph(input);
-    const store = parse(writeTurtle(graph));
-    const iri = activityIri(input);
-    const types = store.getObjects(iri, expand('rdf:type'), null).map(q => q.value);
-    expect(types).toContain(expand('prov:Activity'));
-  });
-
-  it('records the start and end times', () => {
-    const input = makeInput();
-    const graph = emitBuildActivityGraph(input);
-    const store = parse(writeTurtle(graph));
-    const iri = activityIri(input);
-    const generated = store.getObjects(iri, expand('prov:generatedAtTime'), null).map(q => q.value);
-    expect(generated).toContain('2026-06-28T12:05:00Z');
-  });
-
-  it('types the tool as prov:SoftwareAgent with version', () => {
-    const input = makeInput();
-    const graph = emitBuildActivityGraph(input);
-    const store = parse(writeTurtle(graph));
-    const toolIri = `https://glossarist.org/tool/${input.toolId}/${input.toolVersion}`;
-    const types = store.getObjects(toolIri, expand('rdf:type'), null).map(q => q.value);
-    expect(types).toContain(expand('prov:SoftwareAgent'));
-    const version = store.getObjects(toolIri, expand('prov:version'), null).map(q => q.value);
-    expect(version).toContain(input.toolVersion);
-  });
-
-  it('records the git commit and the tool as prov:used entities', () => {
-    const input = makeInput();
-    const graph = emitBuildActivityGraph(input);
-    const store = parse(writeTurtle(graph));
-    const iri = activityIri(input);
-    const used = store.getObjects(iri, expand('prov:used'), null).map(q => q.value);
-    expect(used).toContain(`https://glossarist.org/commit/${input.gitSha}`);
-    expect(used).toContain(`https://glossarist.org/tool/${input.toolId}/${input.toolVersion}`);
-  });
-
-  it('references every dataset register via prov:used', () => {
-    const input = makeInput();
-    const graph = emitBuildActivityGraph(input);
-    const store = parse(writeTurtle(graph));
-    const iri = activityIri(input);
-    const used = store.getObjects(iri, expand('prov:used'), null).map(q => q.value);
-    for (const register of input.datasetRegisters) {
-      expect(used).toContain(`https://glossarist.org/${register}/`);
-    }
-  });
-
-  it('records the concept count as an xsd:integer literal', () => {
-    const input = makeInput();
-    const graph = emitBuildActivityGraph(input);
-    const store = parse(writeTurtle(graph));
-    const iri = activityIri(input);
-    const counts = store.getObjects(iri, 'https://www.glossarist.org/ontologies/conceptCount', null).map(q => q.value);
-    expect(counts).toContain('1234');
-  });
-
-  it('associates the CI agent when provided', () => {
-    const input = makeInput();
-    const graph = emitBuildActivityGraph(input);
-    const store = parse(writeTurtle(graph));
-    const iri = activityIri(input);
-    const agents = store.getObjects(iri, expand('prov:wasAssociatedWith'), null).map(q => q.value);
-    expect(agents).toContain(input.associatedAgentIri);
-
-    const agentTypes = store.getObjects(input.associatedAgentIri!, expand('rdf:type'), null).map(q => q.value);
-    expect(agentTypes).toContain(expand('prov:Agent'));
-  });
-
-  it('omits the commit entity when gitSha is not provided', () => {
-    const input = makeInput({ gitSha: undefined, gitBranch: undefined });
-    const graph = emitBuildActivityGraph(input);
-    const store = parse(writeTurtle(graph));
-    const iri = activityIri(input);
-    const used = store.getObjects(iri, expand('prov:used'), null).map(q => q.value);
-    expect(used.some(u => u.includes('/commit/'))).toBe(false);
-  });
-});

package/src/__tests__/concept-rdf/coerce-date.test.ts

@@ -1,97 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Parser, Store } from 'n3';
-import { Concept } from 'glossarist';
-import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
-import { emitConceptGraph } from '../../components/concept-rdf/concept-emitter';
-
-const G = 'https://www.glossarist.org/ontologies/';
-const XSD = 'http://www.w3.org/2001/XMLSchema#';
-
-function parse(turtle: string): Store {
-  const parser = new Parser({ format: 'Turtle' });
-  const store = new Store();
-  store.addQuads(parser.parse(turtle));
-  return store;
-}
-
-const BASE = 'https://glossarist.org/fixtures/dates';
-
-describe('B4/C — coerceToDateTime handles year-only and month-only dates', () => {
-  it('coerces yyyy-mm-dd to xsd:dateTime unchanged (with T00:00:00Z)', () => {
-    const concept = Concept.fromJSON({
-      id: 'd.1', uri: `${BASE}/d.1`, status: 'valid',
-      dates: [{ type: 'accepted', date: '2020-06-15' }],
-      localizations: {
-        eng: {
-          language_code: 'eng', entry_status: 'valid',
-          terms: [{ type: 'expression', designation: 'd1', normative_status: 'preferred' }],
-          definition: [{ content: 'def' }],
-        },
-      },
-    });
-    const { graph } = emitConceptGraph(concept, concept.uri ?? '');
-    const store = parse(writeTurtle(graph));
-    const dateBlanks = store.getObjects(concept.uri ?? '', `${G}hasDate`, null);
-    const values = store.getObjects(dateBlanks[0], `${G}dateValue`, null);
-    expect((values[0] as any).value).toBe('2020-06-15T00:00:00Z');
-    expect((values[0] as any).datatype.value).toBe(`${XSD}dateTime`);
-  });
-
-  it('coerces year-only "2020" to "2020-01-01T00:00:00Z"', () => {
-    const concept = Concept.fromJSON({
-      id: 'd.2', uri: `${BASE}/d.2`, status: 'valid',
-      dates: [{ type: 'accepted', date: '2020' }],
-      localizations: {
-        eng: {
-          language_code: 'eng', entry_status: 'valid',
-          terms: [{ type: 'expression', designation: 'd2', normative_status: 'preferred' }],
-          definition: [{ content: 'def' }],
-        },
-      },
-    });
-    const { graph } = emitConceptGraph(concept, concept.uri ?? '');
-    const store = parse(writeTurtle(graph));
-    const dateBlanks = store.getObjects(concept.uri ?? '', `${G}hasDate`, null);
-    const values = store.getObjects(dateBlanks[0], `${G}dateValue`, null);
-    expect((values[0] as any).value).toBe('2020-01-01T00:00:00Z');
-    expect((values[0] as any).datatype.value).toBe(`${XSD}dateTime`);
-  });
-
-  it('coerces month-only "2020-06" to "2020-06-01T00:00:00Z"', () => {
-    const concept = Concept.fromJSON({
-      id: 'd.3', uri: `${BASE}/d.3`, status: 'valid',
-      dates: [{ type: 'accepted', date: '2020-06' }],
-      localizations: {
-        eng: {
-          language_code: 'eng', entry_status: 'valid',
-          terms: [{ type: 'expression', designation: 'd3', normative_status: 'preferred' }],
-          definition: [{ content: 'def' }],
-        },
-      },
-    });
-    const { graph } = emitConceptGraph(concept, concept.uri ?? '');
-    const store = parse(writeTurtle(graph));
-    const dateBlanks = store.getObjects(concept.uri ?? '', `${G}hasDate`, null);
-    const values = store.getObjects(dateBlanks[0], `${G}dateValue`, null);
-    expect((values[0] as any).value).toBe('2020-06-01T00:00:00Z');
-  });
-
-  it('passes through ISO 8601 datetimes unchanged', () => {
-    const concept = Concept.fromJSON({
-      id: 'd.4', uri: `${BASE}/d.4`, status: 'valid',
-      dates: [{ type: 'accepted', date: '2020-06-15T13:45:30Z' }],
-      localizations: {
-        eng: {
-          language_code: 'eng', entry_status: 'valid',
-          terms: [{ type: 'expression', designation: 'd4', normative_status: 'preferred' }],
-          definition: [{ content: 'def' }],
-        },
-      },
-    });
-    const { graph } = emitConceptGraph(concept, concept.uri ?? '');
-    const store = parse(writeTurtle(graph));
-    const dateBlanks = store.getObjects(concept.uri ?? '', `${G}hasDate`, null);
-    const values = store.getObjects(dateBlanks[0], `${G}dateValue`, null);
-    expect((values[0] as any).value).toBe('2020-06-15T13:45:30Z');
-  });
-});