glossarist 0.3.7 → 0.4.0

package/src/validators/concept-validator.js

@@ -9,18 +9,13 @@ const VALID_ENTRY_STATUSES = new Set([
   'valid', 'draft', 'retired', 'notValid', 'superseded', 'withdrawn',
 ]);
 
-const _langs = (c) =>
-  c.languages ?? (c.localizations ? Object.keys(c.localizations) : []);
-
-const _loc = (c, lang) =>
-  typeof c.localization === 'function' ? c.localization(lang) : c.localizations?.[lang];
-
 export class LanguageCodeRule extends ValidationRule {
   constructor() { super('language-code'); }
   validate(concept, path, result) {
-    for (const lang of _langs(concept)) {
+    for (const lang of concept.languages) {
       if (!/^[a-z]{3}$/.test(lang)) {
-        result.addError(`${path}localizations.${lang}`,
+        this.addIssue(result,
+          `${path}localizations.${lang}`,
           `Invalid language code '${lang}': expected ISO 639-3 (3 lowercase letters)`);
       }
     }
@@ -30,15 +25,14 @@ export class LanguageCodeRule extends ValidationRule {
 export class DesignationTypeRule extends ValidationRule {
   constructor() { super('designation-type'); }
   validate(concept, path, result) {
-    for (const lang of _langs(concept)) {
-      const lc = _loc(concept, lang);
+    for (const lang of concept.languages) {
+      const lc = concept.localization(lang);
       if (!lc) continue;
-      const terms = lc.terms ?? [];
-      for (let i = 0; i < terms.length; i++) {
-        const t = terms[i];
-        const type = t.type ?? (typeof t.toJSON === 'function' ? t.toJSON().type : undefined);
+      for (let i = 0; i < lc.terms.length; i++) {
+        const type = lc.terms[i].type;
         if (type && !VALID_DESIGNATION_TYPES.has(type)) {
-          result.addError(`${path}localizations.${lang}.terms[${i}].type`,
+          this.addIssue(result,
+            `${path}localizations.${lang}.terms[${i}].type`,
             `Unknown designation type '${type}'`);
         }
       }
@@ -49,13 +43,13 @@ export class DesignationTypeRule extends ValidationRule {
 export class EntryStatusRule extends ValidationRule {
   constructor() { super('entry-status'); }
   validate(concept, path, result) {
-    for (const lang of _langs(concept)) {
-      const lc = _loc(concept, lang);
+    for (const lang of concept.languages) {
+      const lc = concept.localization(lang);
       if (!lc) continue;
-      const status = lc.entryStatus ?? lc.entry_status;
-      if (status && !VALID_ENTRY_STATUSES.has(status)) {
-        result.addError(`${path}localizations.${lang}.entry_status`,
-          `Unknown entry status '${status}'`);
+      if (lc.entryStatus && !VALID_ENTRY_STATUSES.has(lc.entryStatus)) {
+        this.addIssue(result,
+          `${path}localizations.${lang}.entry_status`,
+          `Unknown entry status '${lc.entryStatus}'`);
       }
     }
   }
@@ -71,30 +65,21 @@ export class ConceptValidator {
 
   validate(concept) {
     const result = new ValidationResult();
-    const hasModelApi = typeof concept.localization === 'function';
 
     if (!concept.id) {
       result.addError('id', 'Concept must have an id');
     }
 
-    const langs = hasModelApi ? concept.languages : Object.keys(concept.localizations ?? {});
-    if (langs.length === 0) {
+    if (concept.languages.length === 0) {
       result.addWarning('localizations', 'Concept must have at least one localization');
-    } else if (hasModelApi) {
-      for (const lang of langs) {
+    } else {
+      for (const lang of concept.languages) {
         const lc = concept.localization(lang);
         if (!lc || lc.terms.length === 0) {
           result.addWarning(`localizations.${lang}.terms`,
             `Localization '${lang}' must have at least one term`);
         }
       }
-    } else {
-      for (const [lang, lc] of Object.entries(concept.localizations ?? {})) {
-        if (!lc.terms || lc.terms.length === 0) {
-          result.addWarning(`localizations.${lang}.terms`,
-            `Localization '${lang}' must have at least one term`);
-        }
-      }
     }
 
     for (const rule of this._rules) {

package/src/validators/index.js

@@ -14,6 +14,8 @@ export {
   UuidFormatRule,
   SourceUrnFormatRule,
   CiteRefIntegrityRule,
+  NonVerbalRefIntegrityRule,
+  OrphanedImagesRule,
 } from './v3-rules.js';
 
 import { ConceptValidator, LanguageCodeRule, DesignationTypeRule, EntryStatusRule } from './concept-validator.js';
@@ -29,6 +31,7 @@ import {
   UuidFormatRule,
   SourceUrnFormatRule,
   CiteRefIntegrityRule,
+  NonVerbalRefIntegrityRule,
 } from './v3-rules.js';
 
 const _default = new ConceptValidator()
@@ -43,7 +46,8 @@ const _default = new ConceptValidator()
   .addRule(new UuidFormatRule())
   .addRule(new SourceUrnFormatRule())
   .addRule(new RelationshipTypeRule())
-  .addRule(new CiteRefIntegrityRule());
+  .addRule(new CiteRefIntegrityRule())
+  .addRule(new NonVerbalRefIntegrityRule());
 
 export function validateConcept(concept) {
   return _default.validate(concept);

package/src/validators/v3-rules.js

@@ -1,14 +1,10 @@
 import { ValidationRule } from './validation-rule.js';
-
-const _langs = (concept) =>
-  concept.languages ?? (concept.localizations ? Object.keys(concept.localizations) : []);
-
-const _loc = (concept, lang) =>
-  typeof concept.localization === 'function' ? concept.localization(lang) : concept.localizations?.[lang];
+import { parseMention } from '../reference-mention.js';
+import { GraphicalSymbol } from '../models/designation.js';
 
 const _eachLocalization = (concept, fn) => {
-  for (const lang of _langs(concept)) {
-    const lc = _loc(concept, lang);
+  for (const lang of concept.languages) {
+    const lc = concept.localization(lang);
     if (lc) fn(lang, lc);
   }
 };
@@ -19,7 +15,7 @@ export class RefShapeRule extends ValidationRule {
   validate(concept, path, result) {
     let sourceIdx = 0;
     _eachLocalization(concept, (lang, lc) => {
-      const sources = lc.sources ?? [];
+      const sources = lc.sources;
       for (let i = 0; i < sources.length; i++) {
         sourceIdx++;
         const origin = sources[i].origin;
@@ -38,7 +34,7 @@ export class RefShapeRule extends ValidationRule {
       }
     });
 
-    const related = concept.relatedConcepts ?? concept.related ?? [];
+    const related = concept.relatedConcepts;
     for (let i = 0; i < related.length; i++) {
       const ref = related[i].ref;
       if (!ref) continue;
@@ -56,7 +52,7 @@ export class LocalityCompletenessRule extends ValidationRule {
 
   validate(concept, path, result) {
     _eachLocalization(concept, (lang, lc) => {
-      const sources = lc.sources ?? [];
+      const sources = lc.sources;
       for (let i = 0; i < sources.length; i++) {
         const origin = sources[i].origin;
         if (!origin || !origin.locality) continue;
@@ -81,14 +77,14 @@ export class LocalizationConsistencyRule extends ValidationRule {
   constructor() { super('localization-consistency'); }
 
   validate(concept, path, result) {
-    const langs = _langs(concept);
-    const data = concept.raw?.data || concept;
+    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) && !(concept.localizations?.[lang])) {
+      if (!concept.hasLocalization(lang)) {
         this.addIssue(result,
           `${path}localizations.${lang}`,
           `localized_concepts map has '${lang}' but no localization loaded`);
@@ -101,12 +97,10 @@ export class SchemaVersionRule extends ValidationRule {
   constructor() { super('schema-version', 'warning'); }
 
   validate(concept, path, result) {
-    const version = concept.schemaVersion ?? concept.schema_version;
-
-    if (version && String(version) !== '3') {
+    if (concept.schemaVersion && String(concept.schemaVersion) !== '3') {
       this.addIssue(result,
         `${path}schema_version`,
-        `schema_version is '${version}', expected '3'`);
+        `schema_version is '${concept.schemaVersion}', expected '3'`);
     }
   }
 }
@@ -115,11 +109,8 @@ export class DomainRefRule extends ValidationRule {
   constructor() { super('domain-ref', 'warning'); }
 
   validate(concept, path, result) {
-    const domains = concept.domains || [];
-
-    for (let i = 0; i < domains.length; i++) {
-      const domain = domains[i];
-      const json = typeof domain.toJSON === 'function' ? domain.toJSON() : domain;
+    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}]`,
@@ -134,7 +125,7 @@ export class UuidFormatRule extends ValidationRule {
 
   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 || concept.uuid;
+    const id = concept.id;
 
     if (id && !UUID_RE.test(String(id))) {
       if (String(id).includes('-') && String(id).length > 20) {
@@ -153,7 +144,7 @@ export class SourceUrnFormatRule extends ValidationRule {
     const URN_RE = /^urn:[a-z0-9][a-z0-9-]{0,31}:[a-z0-9()+,\-.:=@;$_!*'%/?#]+$/i;
 
     _eachLocalization(concept, (lang, lc) => {
-      const sources = lc.sources ?? [];
+      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;
@@ -180,23 +171,23 @@ function _findCiteMentions(concept) {
     }
   };
 
-  for (const lang of _langs(concept)) {
-    const lc = _loc(concept, lang);
+  for (const lang of concept.languages) {
+    const lc = concept.localization(lang);
     if (!lc) continue;
 
-    for (let i = 0; (lc.definitions ?? [])[i]; i++) {
+    for (let i = 0; lc.definitions[i]; i++) {
       walkText(lc.definitions[i]?.content, `localizations.${lang}.definitions[${i}].content`);
     }
-    for (let i = 0; (lc.notes ?? [])[i]; i++) {
+    for (let i = 0; lc.notes[i]; i++) {
       const content = typeof lc.notes[i] === 'object'
         ? (lc.notes[i]?.content ?? '')
         : String(lc.notes[i] ?? '');
       walkText(content, `localizations.${lang}.notes[${i}].content`);
     }
-    for (let i = 0; (lc.examples ?? [])[i]; i++) {
+    for (let i = 0; lc.examples[i]; i++) {
       walkText(lc.examples[i]?.content, `localizations.${lang}.examples[${i}].content`);
     }
-    for (let i = 0; (lc.annotations ?? [])[i]; i++) {
+    for (let i = 0; lc.annotations[i]; i++) {
       walkText(lc.annotations[i]?.content, `localizations.${lang}.annotations[${i}].content`);
     }
   }
@@ -212,13 +203,13 @@ function _findDuplicateSourceIds(concept) {
     seen.get(source.id).push(source);
   };
 
-  for (const source of (concept.sources ?? [])) record(source);
-  for (const lang of _langs(concept)) {
-    const lc = _loc(concept, lang);
+  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);
+    for (const source of (lc.sources)) record(source);
+    for (const designation of lc.terms) {
+      for (const source of designation.sources) record(source);
     }
   }
 
@@ -231,17 +222,17 @@ function _findDuplicateSourceIds(concept) {
 
 function _collectSourceIds(concept) {
   const ids = new Set();
-  for (const source of (concept.sources ?? [])) {
+  for (const source of concept.sources) {
     if (source?.id != null) ids.add(source.id);
   }
-  for (const lang of _langs(concept)) {
-    const lc = _loc(concept, lang);
+  for (const lang of concept.languages) {
+    const lc = concept.localization(lang);
     if (!lc) continue;
-    for (const source of (lc.sources ?? [])) {
+    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 ?? [])) {
+    for (const designation of lc.terms) {
+      for (const source of designation.sources) {
         if (source?.id != null) ids.add(source.id);
       }
     }
@@ -278,3 +269,148 @@ export class CiteRefIntegrityRule extends ValidationRule {
     }
   }
 }
+
+
+// ── 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') {
+        mentions.push({ key: parsed.key, source });
+      }
+    }
+  };
+
+  for (const lang of concept.languages) {
+    const lc = concept.localization(lang);
+    if (!lc) continue;
+    for (let i = 0; i < lc.definitions.length; i++) {
+      walkText(lc.definitions[i]?.content,
+        `localizations.${lang}.definitions[${i}].content`);
+    }
+    for (let i = 0; i < lc.notes.length; i++) {
+      walkText(lc.notes[i]?.content,
+        `localizations.${lang}.notes[${i}].content`);
+    }
+    for (let i = 0; i < lc.examples.length; i++) {
+      walkText(lc.examples[i]?.content,
+        `localizations.${lang}.examples[${i}].content`);
+    }
+    for (let i = 0; i < lc.annotations.length; i++) {
+      walkText(lc.annotations[i]?.content,
+        `localizations.${lang}.annotations[${i}].content`);
+    }
+  }
+  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() {
+    this.name = 'orphaned-images';
+    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)) {
+        issues.push({
+          path: imgPath,
+          severity: 'warning',
+          message: `orphaned image: ${imgPath} (not referenced by any concept)`,
+        });
+      }
+    }
+    return issues;
+  }
+}