glossarist 0.4.1 → 0.4.3

package/src/rdf/gloss-localized-concept.js

@@ -0,0 +1,72 @@
+// LocalizedConcept → RDF quads. Mirrors glossarist-ruby's
+// `Rdf::GlossLocalizedConcept` + the `EmitsExtraTriples` hook.
+//
+// Emits BOTH reified SKOS-XL labels AND direct SKOS literals, so consumers
+// that don't implement SKOS-XL still see labels/definitions/notes/examples
+// as plain literals. This is the same shape glossarist-ruby emits after
+// WS-B Phase 1.
+import { PRED, PREFIXES } from './predicates.js';
+import { WELL_KNOWN } from './prefixes.js';
+import { designationToQuads, skosLabelPredicate } from './gloss-designation.js';
+import { detailedDefinitionToQuads } from './gloss-detailed-definition.js';
+import { conceptSourceToQuads } from './gloss-source.js';
+import { namedNode, literal, quad } from './terms.js';
+const DCTERMS_LANGUAGE = `${PREFIXES.dcterms}language`;
+
+export function localizedConceptUri(parentUri, language) {
+  return `${parentUri}/${language}`;
+}
+
+export function* localizedConceptToQuads(localizedConcept, { parentUri, language }) {
+  const subjectUri = localizedConceptUri(parentUri, language);
+  const s = namedNode(subjectUri);
+
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.LocalizedConcept));
+  yield quad(s, namedNode(WELL_KNOWN.rdfType), namedNode(WELL_KNOWN.skosConcept));
+  yield quad(s, namedNode(PRED.gloss.isLocalizationOf), namedNode(parentUri));
+  yield quad(s, namedNode(DCTERMS_LANGUAGE), literal(language));
+
+  if (localizedConcept.entryStatus) {
+    yield quad(s, namedNode(PRED.gloss.hasEntryStatus), namedNode(`${PRED.gloss.$ns}entstatus/${localizedConcept.entryStatus}`));
+  }
+  if (localizedConcept.domain) {
+    yield quad(s, namedNode(PRED.gloss.domain), literal(localizedConcept.domain));
+  }
+  if (localizedConcept.release) {
+    yield quad(s, namedNode(PRED.gloss.release), literal(localizedConcept.release));
+  }
+  if (localizedConcept.script) {
+    yield quad(s, namedNode(PRED.gloss.script), literal(localizedConcept.script));
+  }
+  if (localizedConcept.system) {
+    yield quad(s, namedNode(PRED.gloss.conversionSystem), literal(localizedConcept.system));
+  }
+
+  let desigIndex = 0;
+  for (const designation of localizedConcept.terms ?? []) {
+    yield* designationToQuads(designation, { subjectUri, language, index: desigIndex });
+    // Direct SKOS literal alongside the reified SKOS-XL form.
+    yield quad(s, namedNode(skosLabelPredicate(designation)), literal(designation.designation, language));
+    desigIndex += 1;
+  }
+
+  yield* definitionsToQuads(localizedConcept.definitions, { subjectUri, language, role: 'hasDefinition' });
+  yield* definitionsToQuads(localizedConcept.notes, { subjectUri, language, role: 'hasNote' });
+  yield* definitionsToQuads(localizedConcept.examples, { subjectUri, language, role: 'hasExample' });
+  yield* definitionsToQuads(localizedConcept.annotations, { subjectUri, language, role: 'hasAnnotation' });
+
+  let srcIndex = 0;
+  for (const source of localizedConcept.sources ?? []) {
+    yield* conceptSourceToQuads(source, { subjectUri, index: srcIndex });
+    srcIndex += 1;
+  }
+}
+
+function* definitionsToQuads(definitions, { subjectUri, language, role }) {
+  if (!definitions) return;
+  let i = 0;
+  for (const def of definitions) {
+    yield* detailedDefinitionToQuads(def, { subjectUri, language, index: i, role });
+    i += 1;
+  }
+}

package/src/rdf/gloss-source.js

@@ -0,0 +1,51 @@
+// ConceptSource → RDF quads. Mirrors glossarist-ruby's
+// `Rdf::GlossConceptSource` + `Rdf::GlossCitation`. Sources are reified
+// resources linked from their parent (concept or localized concept or
+// definition) via `gloss:hasSource`.
+import { PRED } from './predicates.js';
+import { WELL_KNOWN } from './prefixes.js';
+import { deterministicBnode } from './deterministic-id.js';
+import { normalizeEnum } from './normalize-enum.js';
+import { namedNode, literal, quad } from './terms.js';
+
+export function* conceptSourceToQuads(source, { subjectUri, index }) {
+  const srcSubject = deterministicBnode(subjectUri, 'source', index);
+
+  yield quad(namedNode(subjectUri), namedNode(PRED.gloss.hasSource), namedNode(srcSubject));
+  yield quad(namedNode(srcSubject), namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.ConceptSource));
+
+  const statusToken = normalizeEnum(source.status);
+  if (statusToken) {
+    yield quad(namedNode(srcSubject), namedNode(PRED.gloss.sourceStatus), namedNode(`${PRED.gloss.$ns}srcstatus/${statusToken}`));
+  }
+  const typeToken = normalizeEnum(source.type);
+  if (typeToken) {
+    yield quad(namedNode(srcSubject), namedNode(PRED.gloss.sourceType), namedNode(`${PRED.gloss.$ns}srctype/${typeToken}`));
+  }
+  if (source.modification) {
+    yield quad(namedNode(srcSubject), namedNode(PRED.gloss.modification), literal(source.modification));
+  }
+
+  if (source.origin) {
+    yield* citationToQuads(source.origin, { subjectUri: srcSubject });
+  }
+}
+
+function* citationToQuads(citation, { subjectUri }) {
+  const citSubject = deterministicBnode(subjectUri, 'origin', 0);
+  yield quad(namedNode(subjectUri), namedNode(PRED.gloss.sourceOrigin), namedNode(citSubject));
+  yield quad(namedNode(citSubject), namedNode(WELL_KNOWN.rdfType), namedNode(PRED.gloss.Citation));
+
+  if (citation.original) {
+    yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationOriginal), literal(citation.original));
+  }
+  if (citation.link) {
+    yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationLink), literal(citation.link));
+  }
+
+  if (citation.ref) {
+    if (citation.ref.source) yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationRefSource), literal(citation.ref.source));
+    if (citation.ref.id) yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationRefId), literal(citation.ref.id));
+    if (citation.ref.version) yield quad(namedNode(citSubject), namedNode(PRED.gloss.citationRefVersion), literal(citation.ref.version));
+  }
+}

package/src/rdf/index.d.ts

@@ -0,0 +1,107 @@
+// Type declarations for the public RDF layer.
+//
+// Mirrors the runtime exports of src/rdf/index.js. Quads use the RDF/JS
+// Quad interface from @rdfjs/dataset (compatible with n3's DataFactory
+// output). Dataset is the RDF/JS Dataset.Core interface.
+
+import type { Quad, Dataset, Term } from '@rdfjs/dataset';
+import type { Concept } from '../models/index';
+import type { LocalizedConcept } from '../models/index';
+import type { Designation } from '../models/index';
+import type { DetailedDefinition } from '../models/index';
+import type { ConceptSource } from '../models/index';
+
+export { PRED, PREFIXES } from './predicates';
+export type PredicateMap = typeof PRED;
+export type PrefixMap = typeof PREFIXES;
+
+export type { Quad, Dataset, Term };
+
+export const SKOSXL: {
+  prefLabel: string;
+  altLabel: string;
+  hiddenLabel: string;
+  literalForm: string;
+};
+
+export const WELL_KNOWN: {
+  rdfType: string;
+  rdfValue: string;
+  skosConcept: string;
+  skosxlLabel: string;
+};
+
+export declare function deterministicId(...parts: Array<string | number | null | undefined>): string;
+export declare function deterministicBnode(subject: string, role: string, index: number): string;
+
+export interface ConceptUriOptions {
+  registerId: string;
+  uriBase?: string;
+}
+
+export declare function conceptUri(concept: Concept | { id?: string; termid?: string }, options: ConceptUriOptions): string;
+export declare function conceptToQuads(concept: Concept, options: ConceptUriOptions): Generator<Quad, void, unknown>;
+
+export interface LocalizedConceptEmitOptions {
+  parentUri: string;
+  language: string;
+}
+
+export declare function localizedConceptUri(parentUri: string, language: string): string;
+export declare function localizedConceptToQuads(localizedConcept: LocalizedConcept, options: LocalizedConceptEmitOptions): Generator<Quad, void, unknown>;
+
+export interface DesignationEmitOptions {
+  subjectUri: string;
+  language: string;
+  index: number;
+}
+
+export declare function designationToQuads(designation: Designation, options: DesignationEmitOptions): Generator<Quad, void, unknown>;
+export declare function skosLabelPredicate(designation: Designation): string;
+export declare function skosxlLabelPredicate(designation: Designation): string;
+
+export interface DetailedDefinitionEmitOptions {
+  subjectUri: string;
+  language?: string;
+  index: number;
+  role: 'hasDefinition' | 'hasNote' | 'hasExample' | 'hasAnnotation' | 'hasScopedExample';
+}
+
+export declare function detailedDefinitionToQuads(definition: DetailedDefinition, options: DetailedDefinitionEmitOptions): Generator<Quad, void, unknown>;
+
+export interface ConceptSourceEmitOptions {
+  subjectUri: string;
+  index: number;
+}
+
+export declare function conceptSourceToQuads(source: ConceptSource, options: ConceptSourceEmitOptions): Generator<Quad, void, unknown>;
+
+export declare function collectQuads(quadsIterable: Iterable<Quad>): Quad[];
+
+export interface WriteTurtleOptions {
+  prefixes?: Record<string, string>;
+}
+
+export declare function writeTurtle(quads: Iterable<Quad>, options?: WriteTurtleOptions): Promise<string>;
+export declare function writeNTriples(quads: Iterable<Quad>): Promise<string>;
+
+export interface WriteJsonldOptions {
+  context?: Record<string, string>;
+}
+
+export declare function writeJsonld(quads: Iterable<Quad>, options?: WriteJsonldOptions): Promise<string>;
+export declare function sortQuads(quads: Iterable<Quad>): Quad[];
+
+export interface ValidationReport {
+  conforms: boolean;
+  results: ReadonlyArray<{
+    focusNode?: Term;
+    shape?: Term;
+    path?: Term;
+    message: Term[];
+  }>;
+}
+
+export declare function loadShapes(): Promise<Dataset>;
+export declare function validateShacl(dataDataset: Dataset, options?: { shapes?: Dataset }): Promise<ValidationReport>;
+export declare function quadsToDataset(quads: Iterable<Quad>): Dataset;

package/src/rdf/index.js

@@ -0,0 +1,27 @@
+// Public RDF layer. Mirrors lib/glossarist/rdf/ in glossarist-ruby.
+export { PRED, PREFIXES, SKOSXL, WELL_KNOWN } from './prefixes.js';
+export { deterministicId, deterministicBnode } from './deterministic-id.js';
+export { namedNode, blankNode, literal, defaultGraph, quad } from './terms.js';
+export {
+  conceptUri,
+  conceptToQuads,
+} from './gloss-concept.js';
+export {
+  localizedConceptUri,
+  localizedConceptToQuads,
+} from './gloss-localized-concept.js';
+export {
+  designationToQuads,
+  skosLabelPredicate,
+  skosxlLabelPredicate,
+} from './gloss-designation.js';
+export { detailedDefinitionToQuads } from './gloss-detailed-definition.js';
+export { conceptSourceToQuads } from './gloss-source.js';
+export {
+  collectQuads,
+  writeTurtle,
+  writeNTriples,
+  writeJsonld,
+  sortQuads,
+} from './document-writer.js';
+export { validateShacl, loadShapes, quadsToDataset } from './shacl.js';

package/src/rdf/normalize-enum.js

@@ -0,0 +1,23 @@
+// Helpers for normalizing enumeration values that get interpolated into
+// URIs. Source data may contain compound forms ("preferred/admitted") or
+// path-like values that must be reduced to a single local name before
+// being embedded in a URI, otherwise the URI is malformed.
+
+// Returns the last path segment of an enumeration value.
+// Examples:
+//   'preferred'             → 'preferred'
+//   'preferred/admitted'    → 'admitted'
+//   'http://x/ns#preferred' → 'preferred'
+//   '' / null / undefined   → '' (caller decides whether to skip emission)
+export function normalizeEnum(value) {
+  if (value == null) return '';
+  const s = String(value).trim();
+  if (!s) return '';
+  const parts = s.split(/[/#]/);
+  return parts[parts.length - 1];
+}
+
+// True when normalizeEnum would produce a non-empty token.
+export function hasEnumValue(value) {
+  return normalizeEnum(value).length > 0;
+}