glossarist 0.4.44 → 0.4.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.4.44",
+  "version": "0.4.46",
   "description": "JavaScript SDK for Glossarist GCR packages — read, write, validate, and manage terminology concepts",
   "type": "module",
   "main": "src/index.js",
@@ -111,6 +111,7 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@rdfjs/types": "^2.0.1",
+    "@types/n3": "^1.26.1",
     "@types/node": "^26.1.2",
     "@typescript-eslint/eslint-plugin": "^8.65.0",
     "@typescript-eslint/parser": "^8.65.0",

package/src/rdf/bnode-id.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
 // Deterministic blank node ID strategy.
 //
 // Single source of truth for bnode IDs across all emitters. Previously
@@ -10,7 +9,7 @@
 // Browser safety: node:crypto is loaded lazily via runtime check so
 // bundlers don't tree-shake the import into the browser bundle.
 
-let nodeCreateHash = null;
+let nodeCreateHash: ((alg: string) => { update(data: string): { digest(enc: string): string } }) | null = null;
 let nodeCryptoChecked = false;
 
 function getNodeCreateHash() {
@@ -22,7 +21,7 @@ function getNodeCreateHash() {
       const mod = (Function('m', 'return require(m)'))('node:module');
       requireFn = mod.createRequire(import.meta.url);
     } catch {
-      requireFn = (m) => (Function('m', 'return require(m)'))(m);
+      requireFn = (m: string) => (Function('m', 'return require(m)'))(m);
     }
     const crypto = requireFn('node:crypto');
     nodeCreateHash = crypto.createHash.bind(crypto);
@@ -32,7 +31,7 @@ function getNodeCreateHash() {
   return nodeCreateHash;
 }
 
-function fnv1a(seed) {
+function fnv1a(seed: string): string {
   let h = 0x811c9dc5;
   for (let i = 0; i < seed.length; i++) {
     h ^= seed.charCodeAt(i);
@@ -41,7 +40,7 @@ function fnv1a(seed) {
   return (h >>> 0).toString(16).padStart(8, '0');
 }
 
-export function deterministicBnodeId(...parts) {
+export function deterministicBnodeId(...parts: ReadonlyArray<unknown>): string {
   const seed = parts.filter(p => p != null && p !== '').join('|');
   if (!seed) return `b${fnv1a('empty')}`;
   const createHash = getNodeCreateHash();

package/src/rdf/curie.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
 // CURIE helpers — resolve/compact IRIs against the canonical PREFIXES.
 //
 // Single source of truth for CURIE ↔ IRI conversion. Previously
@@ -9,7 +8,7 @@ import { PREFIXES } from './prefixes.js';
 
 const ABSOLUTE_SCHEMES = new Set(['http', 'https', 'urn', 'file', 'mailto', 'ftp']);
 
-export function isAbsoluteIri(s) {
+export function isAbsoluteIri(s: string): boolean {
   if (typeof s !== 'string' || s.length === 0) return false;
   if (s.startsWith('urn:')) return true;
   const colon = s.indexOf(':');
@@ -17,17 +16,17 @@ export function isAbsoluteIri(s) {
   return ABSOLUTE_SCHEMES.has(s.slice(0, colon));
 }
 
-export function resolveIri(iri, prefixes = PREFIXES) {
+export function resolveIri(iri: string, prefixes: Record<string, string> = PREFIXES): string {
   if (isAbsoluteIri(iri)) return iri;
   const colon = iri.indexOf(':');
   if (colon < 1) return iri;
   const prefix = iri.slice(0, colon);
   const local = iri.slice(colon + 1);
-  const base = prefixes[prefix];
+  const base = prefixes[prefix as keyof typeof PREFIXES];
   return base ? `${base}${local}` : iri;
 }
 
-export function compactIri(iri, prefixes = PREFIXES) {
+export function compactIri(iri: string, prefixes: Record<string, string> = PREFIXES): string {
   let best = null;
   let bestLen = 0;
   for (const [prefix, base] of Object.entries(prefixes)) {

package/src/rdf/deterministic-id.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
 // Stable ID helpers for RDF emission. Mirrors glossarist-ruby's
 // Digest::MD5.hexdigest(content)[0..11] for cross-runtime stability.
 //
@@ -7,7 +6,7 @@
 // `createRequire` from `node:module` (also lazy) which is the
 // documented way to use CommonJS `require` from ESM.
 
-let nodeCreateHash = null;
+let nodeCreateHash: ((alg: string) => { update(data: string): { digest(enc: string): string } }) | null = null;
 let nodeCryptoChecked = false;
 
 function getNodeCreateHash() {
@@ -23,7 +22,7 @@ function getNodeCreateHash() {
       requireFn = mod.createRequire(import.meta.url);
     } catch {
       // CJS or already-require-available environment
-      requireFn = (m) => (Function('m', 'return require(m)'))(m);
+      requireFn = (m: string) => (Function('m', 'return require(m)'))(m);
     }
     const crypto = requireFn('node:crypto');
     nodeCreateHash = crypto.createHash.bind(crypto);
@@ -37,7 +36,7 @@ function getNodeCreateHash() {
 // `Digest::MD5.hexdigest(content)[0..11]`. Same content → same ID across
 // processes, machines, and language runtimes (Ruby vs JS) when MD5 is
 // available. Falls back to a 12-char FNV-1a hash in the browser.
-export function deterministicId(...parts) {
+export function deterministicId(...parts: ReadonlyArray<unknown>): string {
   const seed = parts.filter(p => p !== null && p !== undefined).join('|');
   const createHash = getNodeCreateHash();
   if (createHash) {
@@ -48,14 +47,12 @@ export function deterministicId(...parts) {
 
 // Stable blank-node label for an RDF fragment identified by its parent
 // subject + role + index.
-export function deterministicBnode(subject, role, index) {
+export function deterministicBnode(subject: string, role: string, index: number): string {
   return `_:b${deterministicId(subject, role, index)}`;
 }
 
-// 12-char FNV-1a hash. Two 32-bit passes concatenated and truncated.
-// Not as collision-resistant as MD5 but adequate for bnode IDs in a
-// single document. Used only when node:crypto is unavailable.
-function fnv1a12(seed) {
+// 12-char FNV-1a hash.
+function fnv1a12(seed: string): string {
   let h1 = 0x811c9dc5;
   for (let i = 0; i < seed.length; i++) {
     h1 ^= seed.charCodeAt(i);

package/src/rdf/normalize-enum.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
 // 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
@@ -10,15 +9,14 @@
 //   'preferred/admitted'    → 'admitted'
 //   'http://x/ns#preferred' → 'preferred'
 //   '' / null / undefined   → '' (caller decides whether to skip emission)
-export function normalizeEnum(value) {
+export function normalizeEnum(value: string | null | undefined): string {
   if (value == null) return '';
   const s = String(value).trim();
   if (!s) return '';
   const parts = s.split(/[/#]/);
-  return parts[parts.length - 1];
+  return parts[parts.length - 1] ?? '';
 }
 
-// True when normalizeEnum would produce a non-empty token.
-export function hasEnumValue(value) {
+export function hasEnumValue(value: string | null | undefined): boolean {
   return normalizeEnum(value).length > 0;
 }

package/src/rdf/prefixes.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
 // Re-export prefix map and predicate constants generated from the vendored
 // concept-model JSON-LD context. Downstream code should never duplicate
 // prefix bindings — always import from here.

package/src/rdf/terms.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
 // Shared RDF/JS term constructors. Replaces the per-emitter
 // `const { namedNode, literal, quad } = DataFactory;` pattern that was
 // repeated across the RDF layer.

package/src/validators/validation-error.ts

@@ -1,16 +1,19 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
 export class ValidationError {
-  constructor(path, message, severity = 'error') {
+  readonly path: string;
+  readonly message: string;
+  readonly severity: 'error' | 'warning';
+
+  constructor(path: string, message: string, severity: 'error' | 'warning' = 'error') {
     this.path = path;
     this.message = message;
     this.severity = severity;
   }
 
-  toString() {
+  toString(): string {
     return `[${this.severity.toUpperCase()}] ${this.path}: ${this.message}`;
   }
 
-  toJSON() {
+  toJSON(): { path: string; message: string; severity: string } {
     return { path: this.path, message: this.message, severity: this.severity };
   }
 }

package/src/validators/validation-result.ts

@@ -1,53 +1,52 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
 import { ValidationError } from './validation-error.js';
 
 export class ValidationResult {
-  constructor() {
-    this._issues = [];
-  }
+  private readonly _issues: ValidationError[] = [];
+
+  constructor() {}
 
-  get valid() {
+  get valid(): boolean {
     return this._issues.filter(e => e.severity === 'error').length === 0;
   }
 
-  get errors() {
+  get errors(): ReadonlyArray<ValidationError> {
     return this._issues.filter(e => e.severity === 'error');
   }
 
-  get warnings() {
+  get warnings(): ReadonlyArray<ValidationError> {
     return this._issues.filter(e => e.severity === 'warning');
   }
 
-  addError(pathOrMessage, message) {
+  addError(path: string, message?: string): this {
     if (message === undefined) {
-      this._issues.push(new ValidationError('', pathOrMessage, 'error'));
+      this._issues.push(new ValidationError('', path, 'error'));
     } else {
-      this._issues.push(new ValidationError(pathOrMessage, message, 'error'));
+      this._issues.push(new ValidationError(path, message, 'error'));
     }
     return this;
   }
 
-  addWarning(pathOrMessage, message) {
+  addWarning(path: string, message?: string): this {
     if (message === undefined) {
-      this._issues.push(new ValidationError('', pathOrMessage, 'warning'));
+      this._issues.push(new ValidationError('', path, 'warning'));
     } else {
-      this._issues.push(new ValidationError(pathOrMessage, message, 'warning'));
+      this._issues.push(new ValidationError(path, message, 'warning'));
     }
     return this;
   }
 
-  merge(other) {
+  merge(other: ValidationResult): this {
     if (other instanceof ValidationResult) {
       for (const issue of other._issues) this._issues.push(issue);
     }
     return this;
   }
 
-  toJSON() {
+  toJSON(): { valid: boolean; errors: unknown[]; warnings: unknown[] } {
     return {
       valid: this.valid,
-      errors: this.errors.map(e => e.toJSON ? e.toJSON() : e),
-      warnings: this.warnings.map(e => e.toJSON ? e.toJSON() : e),
+      errors: this.errors.map(e => typeof e.toJSON === 'function' ? e.toJSON() : e),
+      warnings: this.warnings.map(e => typeof e.toJSON === 'function' ? e.toJSON() : e),
     };
   }
 }

package/src/validators/validation-rule.ts

@@ -1,15 +1,17 @@
-// @ts-nocheck — TEMPORARY during TS migration. TODO(Phase 2e): remove and type fully.
-export class ValidationRule {
-  constructor(name, severity = 'error') {
+import type { ValidationResult } from './validation-result.js';
+
+export abstract class ValidationRule {
+  readonly name: string;
+  readonly severity: 'error' | 'warning';
+
+  constructor(name: string, severity: 'error' | 'warning' = 'error') {
     this.name = name;
     this.severity = severity;
   }
 
-  validate(_value, _path, _result) {
-    throw new Error(`${this.constructor.name} must implement validate()`);
-  }
+  abstract validate(concept: unknown, path: string, result: ValidationResult): void;
 
-  addIssue(result, path, message) {
+  addIssue(result: ValidationResult, path: string, message: string): void {
     if (this.severity === 'warning') {
       result.addWarning(path, message);
     } else {