glossarist 0.4.50 → 0.4.52

package/src/validators/relationship-type-rule.ts

@@ -1,39 +0,0 @@
-import { ValidationRule } from './validation-rule.js';
-import { RELATIONSHIP_TYPES } from '../models/related-concept.js';
-import { DESIGNATION_RELATIONSHIP_TYPES } from '../models/designation-relationship.js';
-
-const KNOWN_CONCEPT_TYPES = new Set(RELATIONSHIP_TYPES);
-const KNOWN_DESIGNATION_TYPES = new Set(DESIGNATION_RELATIONSHIP_TYPES);
-
-export class RelationshipTypeRule extends ValidationRule {
-  constructor() { super('relationship-type', 'warning'); }
-
-  validate(concept, path, result) {
-    const related = concept.relatedConcepts ?? concept.related ?? [];
-    this._checkRelated(related, `${path}related`, KNOWN_CONCEPT_TYPES, result);
-
-    const langs = concept.languages ?? [];
-    for (const lang of langs) {
-      const lc = concept.localization?.(lang);
-      if (!lc) continue;
-
-      this._checkRelated(lc.related, `${path}localizations.${lang}.related`, KNOWN_CONCEPT_TYPES, result);
-
-      for (let ti = 0; ti < lc.terms.length; ti++) {
-        this._checkRelated(lc.terms[ti]?.related,
-          `${path}localizations.${lang}.terms[${ti}].related`, KNOWN_DESIGNATION_TYPES, result);
-      }
-    }
-  }
-
-  _checkRelated(arr, basePath, knownTypes, result) {
-    if (!arr) return;
-    for (let i = 0; i < arr.length; i++) {
-      const type = arr[i]?.type;
-      if (type && !knownTypes.has(type)) {
-        this.addIssue(result, `${basePath}[${i}].type`,
-          `Unknown relationship type '${type}'`);
-      }
-    }
-  }
-}

package/src/validators/sourced-from-locality-rule.ts

@@ -1,53 +0,0 @@
-// Validates that every ConceptSource#sourced_from Citation includes a
-// locality. Per concept-model commit 9c065df ("sourced_from citations
-// must include locality"), a sourced_from entry without a locality is
-// incomplete — the reader cannot locate the definition in the upstream
-// document. The schema (schemas/v3/concept.yaml) enforces this at
-// YAML-load time; this rule surfaces violations in already-parsed
-// Concepts for defense-in-depth.
-//
-// Severity: error. A sourced_from without locality is data loss for
-// the reader.
-
-import { ValidationRule } from './validation-rule.js';
-
-export class SourcedFromLocalityRule extends ValidationRule {
-  constructor() { super('sourced-from-locality', 'error'); }
-
-  validate(concept, path, result) {
-    const sources = concept.sources ?? [];
-    for (let i = 0; i < sources.length; i++) {
-      const source = sources[i];
-      const sourcedFrom = source.sourcedFrom ?? source.sourced_from ?? [];
-      for (let j = 0; j < sourcedFrom.length; j++) {
-        const citation = sourcedFrom[j];
-        const locality = citation?.locality;
-        if (!locality || (!locality.type && !locality.referenceFrom && !locality.reference_from)) {
-          this.addIssue(result,
-            `${path}sources[${i}].sourced_from[${j}].locality`,
-            `sourced_from citation ${j + 1} on source ${i + 1} has no locality ` +
-            `(expected type + reference_from so the reader can locate the definition)`);
-        }
-      }
-    }
-
-    for (const lang of concept.languages ?? []) {
-      const lc = concept.localization?.(lang);
-      if (!lc) continue;
-      const lcSources = lc.sources ?? [];
-      for (let i = 0; i < lcSources.length; i++) {
-        const source = lcSources[i];
-        const sourcedFrom = source.sourcedFrom ?? source.sourced_from ?? [];
-        for (let j = 0; j < sourcedFrom.length; j++) {
-          const citation = sourcedFrom[j];
-          const locality = citation?.locality;
-          if (!locality || (!locality.type && !locality.referenceFrom && !locality.reference_from)) {
-            this.addIssue(result,
-              `${path}localizations.${lang}.sources[${i}].sourced_from[${j}].locality`,
-              `sourced_from citation ${j + 1} on localization source ${i + 1} has no locality`);
-          }
-        }
-      }
-    }
-  }
-}

package/src/validators/v3-rules.ts

@@ -1,382 +0,0 @@
-import { ValidationRule } from './validation-rule.js';
-import { parseMention } from '../reference-mention.js';
-import { GraphicalSymbol } from '../models/designation.js';
-
-const _eachLocalization = (concept, fn) => {
-  for (const lang of concept.languages) {
-    const lc = concept.localization(lang);
-    if (lc) fn(lang, lc);
-  }
-};
-
-export class RefShapeRule extends ValidationRule {
-  constructor() { super('ref-shape'); }
-
-  validate(concept, path, result) {
-    let sourceIdx = 0;
-    _eachLocalization(concept, (lang, lc) => {
-      const sources = lc.sources;
-      for (let i = 0; i < sources.length; i++) {
-        sourceIdx++;
-        const origin = sources[i].origin;
-        if (!origin) continue;
-
-        const ref = origin.ref;
-        if (!ref) {
-          this.addIssue(result,
-            `${path}localizations.${lang}.sources[${i}].origin.ref`,
-            `source ${sourceIdx} origin has nil ref (expected Citation.Ref hash)`);
-        } else if (!ref.source && !ref.id) {
-          this.addIssue(result,
-            `${path}localizations.${lang}.sources[${i}].origin.ref`,
-            `source ${sourceIdx} origin.ref has neither source nor id`);
-        }
-      }
-    });
-
-    const related = concept.relatedConcepts;
-    for (let i = 0; i < related.length; i++) {
-      const ref = related[i].ref;
-      if (!ref) continue;
-      if (!ref.source && !ref.id) {
-        this.addIssue(result,
-          `${path}related[${i}].ref`,
-          `related concept ${i + 1} has empty ref (no source or id)`);
-      }
-    }
-  }
-}
-
-export class LocalityCompletenessRule extends ValidationRule {
-  constructor() { super('locality-completeness', 'warning'); }
-
-  validate(concept, path, result) {
-    _eachLocalization(concept, (lang, lc) => {
-      const sources = lc.sources;
-      for (let i = 0; i < sources.length; i++) {
-        const origin = sources[i].origin;
-        if (!origin || !origin.locality) continue;
-
-        const loc = origin.locality;
-        if (!loc.type) {
-          this.addIssue(result,
-            `${path}localizations.${lang}.sources[${i}].origin.locality.type`,
-            `source locality has no type`);
-        }
-        if (!loc.reference_from && !loc.referenceFrom) {
-          this.addIssue(result,
-            `${path}localizations.${lang}.sources[${i}].origin.locality.reference_from`,
-            `source locality has no reference_from`);
-        }
-      }
-    });
-  }
-}
-
-export class LocalizationConsistencyRule extends ValidationRule {
-  constructor() { super('localization-consistency'); }
-
-  validate(concept, path, result) {
-    const langs = concept.languages;
-    const data = concept.raw?.data || {};
-    const declaredLangs = data.localized_concepts
-      ? Object.keys(data.localized_concepts)
-      : langs;
-
-    for (const lang of declaredLangs) {
-      if (!concept.hasLocalization(lang)) {
-        this.addIssue(result,
-          `${path}localizations.${lang}`,
-          `localized_concepts map has '${lang}' but no localization loaded`);
-      }
-    }
-  }
-}
-
-export class SchemaVersionRule extends ValidationRule {
-  constructor() { super('schema-version', 'warning'); }
-
-  validate(concept, path, result) {
-    if (concept.schemaVersion && String(concept.schemaVersion) !== '3') {
-      this.addIssue(result,
-        `${path}schema_version`,
-        `schema_version is '${concept.schemaVersion}', expected '3'`);
-    }
-  }
-}
-
-export class DomainRefRule extends ValidationRule {
-  constructor() { super('domain-ref', 'warning'); }
-
-  validate(concept, path, result) {
-    for (let i = 0; i < concept.domains.length; i++) {
-      const json = concept.domains[i].toJSON();
-      if (!json.concept_id && !json.urn) {
-        this.addIssue(result,
-          `${path}domains[${i}]`,
-          `domain ${i + 1} has neither concept_id nor urn`);
-      }
-    }
-  }
-}
-
-export class UuidFormatRule extends ValidationRule {
-  constructor() { super('uuid-format'); }
-
-  validate(concept, path, result) {
-    const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    const id = concept.id;
-
-    if (id && !UUID_RE.test(String(id))) {
-      if (String(id).includes('-') && String(id).length > 20) {
-        this.addIssue(result,
-          `${path}id`,
-          `concept ID '${id}' is not valid UUID format`);
-      }
-    }
-  }
-}
-
-export class SourceUrnFormatRule extends ValidationRule {
-  constructor() { super('source-urn-format', 'warning'); }
-
-  validate(concept, path, result) {
-    const URN_RE = /^urn:[a-z0-9][a-z0-9-]{0,31}:[a-z0-9()+,\-.:=@;$_!*'%/?#]+$/i;
-
-    _eachLocalization(concept, (lang, lc) => {
-      const sources = lc.sources;
-      for (let i = 0; i < sources.length; i++) {
-        const source = lc.sources[i].origin?.ref?.source;
-        if (!source || !source.startsWith('urn:')) continue;
-        if (!URN_RE.test(source)) {
-          this.addIssue(result,
-            `${path}localizations.${lang}.sources[${i}].origin.ref.source`,
-            `malformed URN '${source}'`);
-        }
-      }
-    });
-  }
-}
-
-const CITE_MENTION_RE = /\{\{\s*cite:([^,}\s]+)[^}]*?\}\}/g;
-
-function _findCiteMentions(concept) {
-  const mentions = [];
-  for (const { text, source } of concept.walkTexts()) {
-    if (typeof text !== 'string' || text.length === 0) continue;
-    CITE_MENTION_RE.lastIndex = 0;
-    let m;
-    while ((m = CITE_MENTION_RE.exec(text)) !== null) {
-      // @ts-expect-error TODO(Phase 2e): type this fully
-      mentions.push({ key: m[1].trim(), source });
-    }
-  }
-  return mentions;
-}
-
-function _findDuplicateSourceIds(concept) {
-  const seen = new Map();
-  const record = (source) => {
-    if (source?.id == null) return;
-    if (!seen.has(source.id)) seen.set(source.id, []);
-    seen.get(source.id).push(source);
-  };
-
-  for (const source of concept.sources) record(source);
-  for (const lang of concept.languages) {
-    const lc = concept.localization(lang);
-    if (!lc) continue;
-    for (const source of (lc.sources)) record(source);
-    for (const designation of lc.terms) {
-      for (const source of designation.sources) record(source);
-    }
-  }
-
-  const duplicates = new Map();
-  for (const [id, sources] of seen) {
-    if (sources.length > 1) duplicates.set(id, sources);
-  }
-  return duplicates;
-}
-
-function _collectSourceIds(concept) {
-  const ids = new Set();
-  for (const source of concept.sources) {
-    if (source?.id != null) ids.add(source.id);
-  }
-  for (const lang of concept.languages) {
-    const lc = concept.localization(lang);
-    if (!lc) continue;
-    for (const source of (lc.sources)) {
-      if (source?.id != null) ids.add(source.id);
-    }
-    for (const designation of lc.terms) {
-      for (const source of designation.sources) {
-        if (source?.id != null) ids.add(source.id);
-      }
-    }
-  }
-  return ids;
-}
-
-export class CiteRefIntegrityRule extends ValidationRule {
-  constructor() {
-    super('cite-ref-integrity', 'warning');
-  }
-
-  validate(concept, path, result) {
-    // 1. Check unique source ids.
-    const duplicates = _findDuplicateSourceIds(concept);
-    for (const [id] of duplicates) {
-      this.addIssue(result,
-        `${path}sources`,
-        `duplicate source id "${id}" in concept "${concept.id ?? ''}"`);
-    }
-
-    // 2. Check that every inline {{cite:<key>}} mention resolves.
-    const mentions = _findCiteMentions(concept);
-    if (mentions.length === 0) return;
-
-    const knownIds = _collectSourceIds(concept);
-
-    for (const { key, source } of mentions) {
-      if (!knownIds.has(key)) {
-        this.addIssue(result,
-          source,
-          `inline {{cite:${key}}} does not resolve to any source in concept "${concept.id ?? ''}"`);
-      }
-    }
-  }
-}
-
-
-// ── NonVerbalRefIntegrityRule ────────────────────────────────────────
-// Uses parseMention for classification (no regex duplication).
-
-
-const NVR_ARRAYS = Object.freeze([
-  { name: 'figures', entityType: 'figure' },
-  { name: 'tables', entityType: 'table' },
-  { name: 'formulas', entityType: 'formula' },
-]);
-
-function _findNvrMentions(concept) {
-  const mentions = [];
-  const walkText = (text, source) => {
-    if (typeof text !== 'string' || text.length === 0) return;
-    const re = /\{\{([^{}]*?)\}\}/g;
-    let m;
-    while ((m = re.exec(text)) !== null) {
-      const parsed = parseMention(m[1]);
-      if (parsed.kind === 'fig-ref' ||
-          parsed.kind === 'table-ref' ||
-          parsed.kind === 'formula-ref') {
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        mentions.push({ key: parsed.key, source });
-      }
-    }
-  };
-
-  for (const { text, source } of concept.walkTexts()) {
-    walkText(text, source);
-  }
-  return mentions;
-}
-
-export class NonVerbalRefIntegrityRule extends ValidationRule {
-  constructor() {
-    super('nvr-integrity', 'warning');
-  }
-
-  validate(concept, path, result) {
-    for (const { name } of NVR_ARRAYS) {
-      const counts = new Map();
-      for (const ref of concept[name]) {
-        if (ref.entityId == null) continue;
-        counts.set(ref.entityId, (counts.get(ref.entityId) ?? 0) + 1);
-      }
-      for (const [id, count] of counts) {
-        if (count > 1) {
-          this.addIssue(result, `${path}${name}`,
-            `duplicate ${name} reference id "${id}" appears ${count} times`);
-        }
-      }
-    }
-
-    const mentions = _findNvrMentions(concept);
-    if (mentions.length === 0) return;
-
-    const knownIds = new Set();
-    for (const { name } of NVR_ARRAYS) {
-      for (const ref of concept[name]) {
-        if (ref.entityId != null) knownIds.add(ref.entityId);
-      }
-    }
-
-    for (const { key, source } of mentions) {
-      if (!knownIds.has(key)) {
-        this.addIssue(result, source,
-          `inline NVR mention "${key}" does not resolve to any figures/tables/formulas entry`);
-      }
-    }
-  }
-}
-
-// ── OrphanedImagesRule ───────────────────────────────────────────────
-// Collection-scope rule: needs AssetIndex + all concepts. Called
-// directly by GcrValidator (not in concept validator chain).
-
-export class OrphanedImagesRule {
-  constructor() {
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.name = 'orphaned-images';
-    // @ts-expect-error TODO(Phase 2e): type this fully
-    this.severity = 'warning';
-  }
-
-  check(context) {
-    const { assetIndex, concepts, resolver } = context;
-    if (!assetIndex || assetIndex.size === 0) return [];
-
-    const referenced = new Set();
-
-    for (const concept of concepts) {
-      if (resolver) {
-        for (const ref of resolver.extractReferences(concept)) {
-          if (ref.target && ref.target.includes('images/')) {
-            referenced.add(ref.target.replace(/^\//, ''));
-          }
-        }
-      }
-
-      for (const lang of concept.languages) {
-        const lc = concept.localization(lang);
-        if (!lc) continue;
-
-        for (const nvr of lc.nonVerbalRep) {
-          for (const img of nvr.images) {
-            if (img.src) referenced.add(img.src.replace(/^\//, ''));
-          }
-        }
-        for (const term of lc.terms) {
-          if (term instanceof GraphicalSymbol && term.image) {
-            referenced.add(term.image.replace(/^\//, ''));
-          }
-        }
-      }
-    }
-
-    const issues = [];
-    for (const imgPath of assetIndex.paths) {
-      if (!referenced.has(imgPath)) {
-        // @ts-expect-error TODO(Phase 2e): type this fully
-        issues.push({
-          path: imgPath,
-          severity: 'warning',
-          message: `orphaned image: ${imgPath} (not referenced by any concept)`,
-        });
-      }
-    }
-    return issues;
-  }
-}

package/src/validators/validation-error.ts

@@ -1,19 +0,0 @@
-export class ValidationError {
-  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(): string {
-    return `[${this.severity.toUpperCase()}] ${this.path}: ${this.message}`;
-  }
-
-  toJSON(): { path: string; message: string; severity: string } {
-    return { path: this.path, message: this.message, severity: this.severity };
-  }
-}

package/src/validators/validation-result.ts

@@ -1,52 +0,0 @@
-import { ValidationError } from './validation-error.js';
-
-export class ValidationResult {
-  private readonly _issues: ValidationError[] = [];
-
-  constructor() {}
-
-  get valid(): boolean {
-    return this._issues.filter(e => e.severity === 'error').length === 0;
-  }
-
-  get errors(): ReadonlyArray<ValidationError> {
-    return this._issues.filter(e => e.severity === 'error');
-  }
-
-  get warnings(): ReadonlyArray<ValidationError> {
-    return this._issues.filter(e => e.severity === 'warning');
-  }
-
-  addError(path: string, message?: string): this {
-    if (message === undefined) {
-      this._issues.push(new ValidationError('', path, 'error'));
-    } else {
-      this._issues.push(new ValidationError(path, message, 'error'));
-    }
-    return this;
-  }
-
-  addWarning(path: string, message?: string): this {
-    if (message === undefined) {
-      this._issues.push(new ValidationError('', path, 'warning'));
-    } else {
-      this._issues.push(new ValidationError(path, message, 'warning'));
-    }
-    return this;
-  }
-
-  merge(other: ValidationResult): this {
-    if (other instanceof ValidationResult) {
-      for (const issue of other._issues) this._issues.push(issue);
-    }
-    return this;
-  }
-
-  toJSON(): { valid: boolean; errors: unknown[]; warnings: unknown[] } {
-    return {
-      valid: this.valid,
-      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,21 +0,0 @@
-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;
-  }
-
-  abstract validate(concept: unknown, path: string, result: ValidationResult): void;
-
-  addIssue(result: ValidationResult, path: string, message: string): void {
-    if (this.severity === 'warning') {
-      result.addWarning(path, message);
-    } else {
-      result.addError(path, message);
-    }
-  }
-}