glossarist 0.4.50 → 0.4.51

package/src/rdf/version-emitter.ts

@@ -1,97 +0,0 @@
-// Version emitter — emits prov:Entity version chain per dataset.
-// Mirrors concept-browser's version-emitter.ts.
-//
-// Each version of a dataset becomes a prov:Entity typed resource with:
-// - dcterms:isVersionOf → the dataset
-// - prov:wasRevisionOf → previous version (when provided)
-// - prov:generatedAtTime (xsd:dateTime)
-// - dcterms:description (optional change summary)
-// - prov:wasAssociatedWith (optional agent)
-
-import { namedNode, literal, quad } from './terms.js';
-import { PREFIXES } from './prefixes.js';
-import { RDF_TYPE } from './curie.js';
-
-const PROV_NS    = PREFIXES.prov;
-const DCTERMS_NS = PREFIXES.dcterms;
-const XSD_NS     = PREFIXES.xsd;
-
-const PROV = {
-  Entity: `${PROV_NS}Entity`,
-  wasRevisionOf: `${PROV_NS}wasRevisionOf`,
-  generatedAtTime: `${PROV_NS}generatedAtTime`,
-  wasAssociatedWith: `${PROV_NS}wasAssociatedWith`,
-};
-const DCTERMS = {
-  isVersionOf: `${DCTERMS_NS}isVersionOf`,
-  description: `${DCTERMS_NS}description`,
-};
-const XSD_DATE_TIME = `${XSD_NS}dateTime`;
-
-/**
- * @typedef {Object} DatasetVersionInput
- * @property {string} registerId
- * @property {string} version
- * @property {string} versionIri
- * @property {string} datasetIri
- * @property {string} generatedAt — ISO date-time
- * @property {string} [previousVersionIri]
- * @property {string} [changeSummary]
- * @property {string} [associatedAgentIri]
- */
-/**
- * @typedef {Object} VersionHistoryEntry
- * @property {string} version
- * @property {string} generatedAt
- * @property {string} [changeSummary]
- */
-/**
- * @typedef {Object} VersionEmitAllInput
- * @property {string} registerId
- * @property {string} datasetIri
- * @property {readonly VersionHistoryEntry[]} versions
- * @property {string} [associatedAgentIri]
- */
-
-/**
- * Emits a single prov:Entity version with its provenance chain.
- */
-export function* versionToQuads(input) {
-  const v = namedNode(input.versionIri);
-  yield quad(v, namedNode(RDF_TYPE), namedNode(PROV.Entity));
-  yield quad(v, namedNode(DCTERMS.isVersionOf), namedNode(input.datasetIri));
-  if (input.previousVersionIri) {
-    yield quad(v, namedNode(PROV.wasRevisionOf), namedNode(input.previousVersionIri));
-  }
-  yield quad(v, namedNode(PROV.generatedAtTime), literal(input.generatedAt, namedNode(XSD_DATE_TIME)));
-  if (input.changeSummary) {
-    yield quad(v, namedNode(DCTERMS.description), literal(input.changeSummary));
-  }
-  if (input.associatedAgentIri) {
-    yield quad(v, namedNode(PROV.wasAssociatedWith), namedNode(input.associatedAgentIri));
-  }
-}
-
-/**
- * Emits the full version history chain. Versions are linked in
- * sequence via prov:wasRevisionOf (newest → previous → ... → oldest).
- *
- * The version IRI is constructed as `${datasetIri}versions/${version}`.
- */
-export function* versionHistoryToQuads(input) {
-  let previousIri;
-  for (const v of input.versions ?? []) {
-    const versionIri = `${input.datasetIri}versions/${v.version}`;
-    yield* versionToQuads({
-      registerId: input.registerId,
-      version: v.version,
-      versionIri,
-      datasetIri: input.datasetIri,
-      generatedAt: v.generatedAt,
-      previousVersionIri: previousIri,
-      changeSummary: v.changeSummary,
-      associatedAgentIri: input.associatedAgentIri,
-    });
-    previousIri = versionIri;
-  }
-}

package/src/rdf/vocabulary-emitter.ts

@@ -1,67 +0,0 @@
-// Vocabulary graph emitter — emits SKOS ConceptSchemes for the
-// enumeration IRIs that glossarist emits in instance data
-// (gloss:status/*, gloss:entstatus/*, gloss:norm/*, gloss:srcstatus/*,
-// gloss:srctype/*, gloss:datetype/*, gloss:rel/*, etc.).
-//
-// Each enumeration value becomes a skos:Concept in its corresponding
-// skos:ConceptScheme. The scheme uses skos:hasTopConcept to link to
-// its members; members use skos:inScheme to link back.
-//
-// Accepts the schemes data as a plain object — no fs deps, browser-safe.
-// Callers can load the JSON file themselves (Node) or construct the
-// data inline. CURIEs in the input are resolved to absolute IRIs via
-// PREFIXES.
-
-import { namedNode, literal, quad } from './terms.js';
-import { PREFIXES } from './prefixes.js';
-import { resolveIri, RDF_TYPE, RDFS_LABEL } from './curie.js';
-
-const SKOS_NS = PREFIXES.skos;
-
-/**
- * @typedef {Object} VocabTerm
- * @property {string} iri — absolute IRI or CURIE (resolved via PREFIXES)
- * @property {string} label — human-readable label (typically English)
- */
-/**
- * @typedef {Object} VocabScheme
- * @property {string} schemeIri — absolute IRI or CURIE
- * @property {string} label
- * @property {readonly VocabTerm[]} terms
- */
-
-/**
- * Emits SKOS ConceptScheme + Concept quads for one scheme.
- *
- * @param {VocabScheme} scheme
- * @returns {Generator<Quad, void, unknown>}
- */
-export function* vocabularySchemeToQuads(scheme) {
-  const schemeIri = resolveIri(scheme.schemeIri);
-  const schemeSubject = namedNode(schemeIri);
-
-  yield quad(schemeSubject, namedNode(RDF_TYPE), namedNode(`${SKOS_NS}ConceptScheme`));
-  yield quad(schemeSubject, namedNode(RDFS_LABEL), literal(scheme.label, 'en'));
-
-  for (const term of scheme.terms ?? []) {
-    const termIri = resolveIri(term.iri);
-    const termSubject = namedNode(termIri);
-
-    yield quad(termSubject, namedNode(RDF_TYPE), namedNode(`${SKOS_NS}Concept`));
-    yield quad(termSubject, namedNode(RDFS_LABEL), literal(term.label, 'en'));
-    yield quad(termSubject, namedNode(`${SKOS_NS}inScheme`), schemeSubject);
-    yield quad(schemeSubject, namedNode(`${SKOS_NS}hasTopConcept`), termSubject);
-  }
-}
-
-/**
- * Emits SKOS ConceptScheme + Concept quads for many schemes.
- *
- * @param {readonly VocabScheme[]} schemes
- * @returns {Generator<Quad, void, unknown>}
- */
-export function* vocabularyToQuads(schemes) {
-  for (const scheme of schemes ?? []) {
-    yield* vocabularySchemeToQuads(scheme);
-  }
-}

package/src/rdf/write-turtle-sync.ts

@@ -1,179 +0,0 @@
-// Sync Turtle writer — produces Turtle from RDF/JS Quads without
-// n3's callback API. Designed for UI use cases (Vue computed, React
-// render) that need synchronous output.
-//
-// Format matches n3's Turtle output closely but may differ in:
-// - Indent width (2 spaces vs n3's 4)
-// - Blank node label format (_:bXXXX)
-// - Subject ordering (sorted by value for determinism)
-//
-// For byte-equivalent n3 output, use the async writeTurtle() instead.
-
-const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
-
-/**
- * Serializes RDF/JS Quads to a Turtle string synchronously.
- *
- * @param {Iterable<Quad>} quads
- * @param {{ prefixes?: Record<string, string> }} [options]
- * @returns {string}
- */
-export function writeTurtleSync(quads, options = {}) {
-  // @ts-expect-error TODO(Phase 2e): type this fully
-  const prefixes = options.prefixes ?? {};
-  const sorted = [...quads].sort(compareQuadSync);
-  const grouped = groupBySubject(sorted);
-
-  const lines = [];
-
-  // Prefix declarations — sorted by prefix name for deterministic output.
-  for (const [prefix, iri] of Object.entries(prefixes).sort(([a], [b]) => a.localeCompare(b))) {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    lines.push(`@prefix ${prefix}: <${iri}> .`);
-  }
-
-  for (const { subject, triples } of grouped) {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    lines.push('');
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    lines.push(...writeResource(subject, triples, prefixes));
-  }
-
-  return lines.join('\n') + '\n';
-}
-
-function writeResource(subject, triples, prefixes) {
-  const subjectStr = formatTermSync(subject, prefixes);
-  const types = triples.filter(t => t.predicate.value === RDF_TYPE);
-  const others = triples.filter(t => t.predicate.value !== RDF_TYPE);
-
-  if (types.length === 0 && others.length === 0) {
-    return [`${subjectStr} .`];
-  }
-
-  const lines = [];
-  const allPredObjs = [];
-
-  if (types.length > 0) {
-    const typeStrs = types.map(t => formatTermSync(t.object, prefixes));
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    allPredObjs.push({ predStr: 'a', objStrs: typeStrs });
-  }
-
-  // Group by predicate for multi-value compaction (predicate only appears once
-  // with comma-separated objects).
-  const byPredicate = new Map();
-  for (const t of others) {
-    const predStr = formatTermSync(t.predicate, prefixes);
-    if (!byPredicate.has(predStr)) byPredicate.set(predStr, []);
-    byPredicate.get(predStr).push(formatTermSync(t.object, prefixes));
-  }
-  for (const [predStr, objStrs] of byPredicate) {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    allPredObjs.push({ predStr, objStrs });
-  }
-
-  // @ts-expect-error TODO(Phase 2e): type this fully
-  lines.push(`${subjectStr} ${allPredObjs[0].predStr} ${allPredObjs[0].objStrs.join(', ')} ;`);
-  for (let i = 1; i < allPredObjs.length; i++) {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    lines.push(`  ${allPredObjs[i].predStr} ${allPredObjs[i].objStrs.join(', ')} ;`);
-  }
-  // Replace trailing ; with .
-  // @ts-expect-error TODO(Phase 2e): type this fully
-  lines[lines.length - 1] = lines[lines.length - 1].replace(/ ;$/, ' .');
-  return lines;
-}
-
-function formatTermSync(term, prefixes) {
-  switch (term.termType) {
-    case 'NamedNode':
-      return compactIriSync(term.value, prefixes);
-    case 'BlankNode':
-      return `_:${term.value}`;
-    case 'Literal':
-      return formatLiteralSync(term);
-    case 'DefaultGraph':
-      return '';
-    default:
-      return String(term.value ?? term);
-  }
-}
-
-function formatLiteralSync(lit) {
-  const escaped = escapeLiteralSync(lit.value);
-  if (lit.language) return `"${escaped}"@${lit.language}`;
-  const dt = lit.datatype?.value;
-  if (dt && dt !== 'http://www.w3.org/2001/XMLSchema#string') {
-    return `"${escaped}"^^<${dt}>`;
-  }
-  return `"${escaped}"`;
-}
-
-function escapeLiteralSync(s) {
-  return String(s)
-    .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"')
-    .replace(/\n/g, '\\n')
-    .replace(/\r/g, '\\r')
-    .replace(/\t/g, '\\t');
-}
-
-function compactIriSync(iri, prefixes) {
-  // If no prefixes, always use <>
-  if (!prefixes || Object.keys(prefixes).length === 0) {
-    return `<${iri}>`;
-  }
-  // Try longest prefix match
-  let bestPrefix = null;
-  let bestLen = 0;
-  for (const [prefix, base] of Object.entries(prefixes)) {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    if (iri.startsWith(base) && base.length > bestLen) {
-      // Reject if local part contains characters that can't appear in a
-      // Turtle pname-local (e.g. leading digit is fine per Turtle 1.1,
-      // but // is not).
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      const local = iri.slice(base.length);
-      if (!local.startsWith('//')) {
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        bestPrefix = prefix;
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        bestLen = base.length;
-      }
-    }
-  }
-  if (!bestPrefix) return `<${iri}>`;
-  const local = iri.slice(bestLen);
-  const escaped = local.replace(/([/])/g, '\\$1');
-  return `${bestPrefix}:${escaped}`;
-}
-
-function compareQuadSync(a, b) {
-  let cmp = cmpTermSync(a.subject, b.subject);
-  if (cmp !== 0) return cmp;
-  cmp = cmpTermSync(a.predicate, b.predicate);
-  if (cmp !== 0) return cmp;
-  return cmpTermSync(a.object, b.object);
-}
-
-function cmpTermSync(a, b) {
-  if (a.termType !== b.termType) return a.termType.localeCompare(b.termType);
-  return String(a.value).localeCompare(String(b.value));
-}
-
-function groupBySubject(quads) {
-  const map = new Map();
-  for (const q of quads) {
-    const key = termKey(q.subject);
-    if (!map.has(key)) {
-      map.set(key, { subject: q.subject, triples: [] });
-    }
-    map.get(key).triples.push({ predicate: q.predicate, object: q.object });
-  }
-  return [...map.values()];
-}
-
-function termKey(term) {
-  return `${term.termType}:${term.value}`;
-}

package/src/reference-mention.ts

@@ -1,114 +0,0 @@
-/**
- * Mention parser for {{...}} inline references in concept text.
- *
- * Pure function: takes a raw mention body (the text inside
- * {{...}}) and returns a structured MentionParseResult.
- *
- * Convention: the ID always comes first, the display (render) text
- * always comes last.  Every comma-separated form follows this:
- *
- *   {{cite:key}}                  cite-key (source id)
- *   {{cite:key, render term}}     cite-key + render term
- *   {{urn:...}}                   URN reference
- *   {{urn:..., render term}}      URN + render term
- *   {{numeric_id}}                local concept ID
- *   {{numeric_id, render term}}   local concept ID + render term
- *   {{designation}}               designation matching
- *   {{designation, render term}}  designation + render term
- *
- * @typedef {Object} MentionParseResult
- * @property {'cite-ref' | 'urn-ref' | 'numeric' | 'designation' | 'unresolved'} kind
- * @property {string} [key]   — for 'cite-ref': the local key
- * @property {string} [uri]   — for 'urn-ref': the URN
- * @property {string} [label] — render text (always last)
- * @property {string} [id]    — for 'numeric' / 'designation': the id
- * @property {string} raw     — the original mention body
- */
-
-const NUMERIC_RE = /^\d+(?:[.-]\d+)+$/;
-
-const NVR_PREFIXES = Object.freeze([
-  { prefix: 'fig:', kind: 'fig-ref' },
-  { prefix: 'table:', kind: 'table-ref' },
-  { prefix: 'formula:', kind: 'formula-ref' },
-]);
-
-/**
- * Parse the body of a {{...}} mention (without the braces).
- *
- * The function is pure: no I/O, no model lookups, no state.
- * Resolution of the parsed result is the extractor's job.
- *
- * @param {string} raw — the trimmed text inside {{...}}
- * @returns {MentionParseResult}
- */
-export function parseMention(raw) {
-  const body = raw.trim();
-
-  // 1. cite:<key>[,render] — explicit citation reference.
-  const citeMatch = body.match(/^cite:([^,}]+)(?:,(.*))?$/);
-  if (citeMatch) {
-    const label = citeMatch[2] !== undefined ? unquoteLabel(citeMatch[2].trim()) : null;
-    return {
-      kind: 'cite-ref',
-      key: citeMatch[1].trim(),
-      label,
-      raw: body,
-    };
-  }
-
-  // 2. urn:...[,render] — URN reference.
-  const urnMatch = body.match(/^(urn:[^,}]+)(?:,(.*))?$/);
-  if (urnMatch) {
-    const label = urnMatch[2] !== undefined ? unquoteLabel(urnMatch[2].trim()) : null;
-    return {
-      kind: 'urn-ref',
-      uri: urnMatch[1].trim(),
-      label,
-      raw: body,
-    };
-  }
-
-  // 3. NVR prefixes (fig:/table:/formula:) — config-driven dispatch.
-  for (const { prefix, kind } of NVR_PREFIXES) {
-    const escPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const match = body.match(new RegExp(`^${escPrefix}([^,}]+)(?:,(.*))?$`));
-    if (match) {
-      const label = match[2] !== undefined ? unquoteLabel(match[2].trim()) : null;
-      return { kind, key: match[1].trim(), label, raw: body };
-    }
-  }
-
-  // 4. Comma-separated form: {{id, render}}.
-  //    ID always comes first, render text always comes last.
-  const commaIdx = body.indexOf(',');
-  if (commaIdx !== -1) {
-    const id = body.slice(0, commaIdx).trim();
-    const label = unquoteLabel(body.slice(commaIdx + 1).trim());
-
-    if (NUMERIC_RE.test(id)) {
-      return { kind: 'numeric', id, label, raw: body };
-    }
-    return { kind: 'designation', id, label, raw: body };
-  }
-
-  // 5. Bare numeric id.
-  if (NUMERIC_RE.test(body)) {
-    return { kind: 'numeric', id: body, label: null, raw: body };
-  }
-
-  // 6. Anything else is unresolved at the parse layer.
-  return { kind: 'unresolved', raw: body };
-}
-
-/**
- * Strip surrounding double quotes from a label, unescaping
- * CSV-style "" to a single ". If the input is not quoted,
- * return it unchanged.
- */
-function unquoteLabel(label) {
-  if (label.length >= 2 && label.startsWith('"') && label.endsWith('"')) {
-    return label.slice(1, -1).replace(/""/g, '"');
-  }
-  return label;
-}