@glossarist/concept-browser 0.7.66 → 0.7.68

package/src/components/use-rdf-document.ts

@@ -0,0 +1,137 @@
+import type { ComputedRef } from 'vue';
+import { computed } from 'vue';
+import type { Concept } from 'glossarist';
+import {
+  conceptToQuads,
+  provenanceToQuads,
+  quadSectionsToClassInstances,
+  writeTurtleSync,
+  collectQuads,
+  PREFIXES,
+  type ClassInstance,
+  type PropValue,
+  type Quad,
+} from 'glossarist/rdf';
+
+export type { ClassInstance, PropValue };
+
+export interface RdfDocument {
+  sections: ComputedRef<ClassInstance[]>;
+  turtle: ComputedRef<string>;
+  jsonld: ComputedRef<string>;
+  typeChain: ComputedRef<string[]>;
+}
+
+export interface UseRdfDocumentOptions {
+  readonly registerId?: string;
+  readonly uriBase?: string;
+  readonly lazy?: boolean;
+}
+
+const SERIALIZER_VERSION =
+  typeof __CONCEPT_BROWSER_VERSION__ !== 'undefined'
+    ? __CONCEPT_BROWSER_VERSION__
+    : 'dev';
+
+function formatJsonLd(quads: readonly Quad[]): string {
+  // Minimal sync JSON-LD serializer: @context + @graph array of nodes.
+  // Predicates and types are emitted as compact IRIs; values are emitted
+  // as their term-type-appropriate JSON form.
+  const context: Record<string, string> = {};
+  for (const prefix of ['gloss', 'skos', 'skosxl', 'dcterms', 'prov', 'rdf', 'rdfs', 'xsd', 'owl']) {
+    // Skip — handled by RDF_PREFIXES for the Vue UI; JSON-LD context is
+    // minimal here because glossarist/rdf's writeJsonld is async and
+    // the composable must stay sync.
+  }
+
+  // Group quads by subject
+  const bySubject = new Map<string, { subject: string; quads: Quad[] }>();
+  const order: string[] = [];
+  for (const q of quads) {
+    const s = q.subject.value;
+    if (!bySubject.has(s)) {
+      bySubject.set(s, { subject: s, quads: [] });
+      order.push(s);
+    }
+    bySubject.get(s)!.quads.push(q);
+  }
+
+  const nodes = order.map(s => {
+    const entry = bySubject.get(s)!;
+    const node: Record<string, unknown> = { '@id': entry.subject };
+    const types: string[] = [];
+    const props: Record<string, unknown[]> = {};
+
+    for (const q of entry.quads) {
+      if (q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type') {
+        types.push(q.object.value);
+        continue;
+      }
+      const pred = q.predicate.value;
+      const val = termToJsonLd(q.object);
+      if (!props[pred]) props[pred] = [];
+      props[pred].push(val);
+    }
+
+    if (types.length === 1) node['@type'] = types[0];
+    else if (types.length > 1) node['@type'] = types;
+
+    for (const [pred, vals] of Object.entries(props)) {
+      node[pred] = vals.length === 1 ? vals[0] : vals;
+    }
+    return node;
+  });
+
+  return JSON.stringify({ '@context': context, '@graph': nodes }, null, 2);
+}
+
+function termToJsonLd(term: Quad['object']): unknown {
+  switch (term.termType) {
+    case 'NamedNode':
+      return { '@id': term.value };
+    case 'Literal':
+      if (term.language) return { '@value': term.value, '@language': term.language };
+      if (term.datatype && term.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+        return { '@value': term.value, '@type': term.datatype.value };
+      }
+      return term.value;
+    case 'BlankNode':
+      return { '@id': `_:${term.value}` };
+    default:
+      return term.value;
+  }
+}
+
+export function useRdfDocument(
+  getConcept: () => Concept,
+  getConceptUri: () => string,
+  options: UseRdfDocumentOptions = {},
+): RdfDocument {
+  const emission = computed(() => {
+    const concept = getConcept();
+    const uri = getConceptUri();
+    const conceptQuads = collectQuads(
+      conceptToQuads(concept, {
+        registerId: options.registerId ?? '',
+        uriBase: options.uriBase ?? '',
+      }),
+    );
+    const provenanceQuads = collectQuads(
+      provenanceToQuads({
+        subjectUri: uri,
+        serializer: 'concept-browser',
+        serializerVersion: SERIALIZER_VERSION,
+        generatedAt: new Date().toISOString(),
+      }),
+    );
+    return [...conceptQuads, ...provenanceQuads];
+  });
+
+  const sections = computed(() => quadSectionsToClassInstances(emission.value));
+  const turtle = computed(() => writeTurtleSync(emission.value, { prefixes: PREFIXES }));
+  const jsonld = computed(() => formatJsonLd(emission.value));
+
+  const typeChain = computed(() => ['owl:Thing', 'skos:Concept', 'gloss:Concept']);
+
+  return { sections, turtle, jsonld, typeChain };
+}

package/src/composables/useDatasetSeries.ts

@@ -92,7 +92,7 @@ function deriveSeriesTitle(m: Manifest | undefined): string {
 }
 
 function manifestToMember(m: Manifest, activeDatasetId?: string): DatasetSeriesMember {
-  const year = extractYear(m.id) ?? extractYear(m.ref ?? '') ?? extractYear(m.title);
+  const year = m.year ?? extractYear(m.id) ?? extractYear(m.ref ?? '') ?? extractYear(m.title);
   return {
     id: m.id,
     ref: m.ref ?? m.title,

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');
-  });
-});