glossarist 0.3.4 → 0.3.6

package/src/render-classification.js

@@ -0,0 +1,106 @@
+/**
+ * Classify a Reference for rendering.
+ *
+ * The classifier is constructed once per render with a registry
+ * (and optional source dataset id). The classify() method is
+ * pure and side-effect-free.
+ *
+ * Each `Reference.type` is its own `_classifyXxx` method. The
+ * dispatch in classify() is closed for modification.
+ */
+
+export class ReferenceClassifier {
+  /**
+   * @param {object} registry — the deployment's dataset registry.
+   * @param {string} [sourceDatasetId] — the dataset the source
+   *   concept belongs to; used to determine "same-dataset".
+   * @param {object} [options] — additional options (e.g. scope).
+   */
+  constructor(registry = {}, sourceDatasetId = null, options = {}) {
+    this.registry = registry;
+    this.sourceDatasetId = sourceDatasetId;
+    this.options = options;
+  }
+
+  /**
+   * @param {Reference} ref
+   * @returns {string} — the classification (e.g. 'same-dataset',
+   *   'internal-citation', 'unresolved', etc.)
+   */
+  classify(ref) {
+    if (ref == null) return 'unknown';
+
+    switch (ref.type) {
+      case 'concept':    return this._classifyConcept(ref);
+      case 'dataset':    return this._classifyDataset(ref);
+      case 'bibliography': return this._classifyBibliography(ref);
+      case 'typed-ref':  return this._classifyTypedRef(ref);
+      case 'standard':   return 'legacy-standard';
+      default:           return 'unknown';
+    }
+  }
+
+  _classifyConcept(ref) {
+    // 1. URI form, resolved to a dataset.
+    if (ref.uri) {
+      const dsId = ref.resolution?.datasetId;
+      if (!dsId) return 'unresolved';
+      if (!this.registry[dsId]) return 'external-citation';
+      if (dsId === this.sourceDatasetId) return 'same-dataset';
+      return 'cross-dataset';
+    }
+    // 2. Unanchored designation.
+    if (ref.lookupKey?.designation) {
+      return 'unresolved-designation';
+    }
+    // 3. Id-style (id-match, short-id, numeric).
+    if (ref.lookupKey?.id) {
+      const dsId = ref.lookupKey.dataset;
+      if (!this.registry[dsId]) return 'unresolved';
+      if (dsId === this.sourceDatasetId) return 'same-dataset';
+      return 'cross-dataset';
+    }
+    // 4. Concept ref with target (legacy).
+    if (ref.target) {
+      return 'unresolved';
+    }
+    return 'unresolved';
+  }
+
+  _classifyDataset(ref) {
+    if (ref.resolution?.kind === 'dataset-self') return 'dataset-self';
+    if (ref.resolution?.kind === 'dataset-namespace') return 'dataset-self';
+    return 'unknown';
+  }
+
+  _classifyBibliography(ref) {
+    // 1. cite:key form: try the bibliography registry.
+    if (ref.citation) {
+      const bioRecord = this._tryBibliography(ref.citation.ref);
+      if (bioRecord) return 'internal-citation';
+      return 'self-contained-citation';
+    }
+    // 2. URI form: try the bibliography registry, then the
+    //    resolution's datasetId (if it's a concept URI), else null.
+    if (ref.uri) {
+      const bioRecord = this._tryBibliography(ref.resolution);
+      if (bioRecord) return 'internal-citation';
+      return 'external-citation';
+    }
+    return 'unresolved-citation';
+  }
+
+  _classifyTypedRef(_ref) {
+    return 'typed-ref';
+  }
+
+  _tryBibliography(citationRef) {
+    if (!citationRef?.source || !citationRef?.id) return null;
+    const bioColl = this.registry[`bibliography:${citationRef.source}`]?.concepts;
+    if (!bioColl) return null;
+    if (citationRef.version) {
+      return bioColl.byIdAnd(citationRef.id, citationRef.version) ?? null;
+    }
+    return bioColl.byId(citationRef.id) ?? null;
+  }
+}

package/src/validators/concept-validator.js

@@ -1,5 +1,5 @@
 import { ValidationRule } from './validation-rule.js';
-import { ValidationError } from './validation-error.js';
+import { ValidationResult } from './validation-result.js';
 
 const VALID_DESIGNATION_TYPES = new Set([
   'expression', 'abbreviation', 'symbol', 'graphical symbol', 'graphical_symbol',
@@ -9,51 +9,55 @@ 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(value, path) {
-    if (!value.localizations) return [];
-    const errors = [];
-    for (const lang of Object.keys(value.localizations)) {
+  validate(concept, path, result) {
+    for (const lang of _langs(concept)) {
       if (!/^[a-z]{3}$/.test(lang)) {
-        errors.push(...this.error(`${path}localizations.${lang}`,
-          `Invalid language code '${lang}': expected ISO 639-3 (3 lowercase letters)`));
+        result.addError(`${path}localizations.${lang}`,
+          `Invalid language code '${lang}': expected ISO 639-3 (3 lowercase letters)`);
       }
     }
-    return errors;
   }
 }
 
 export class DesignationTypeRule extends ValidationRule {
   constructor() { super('designation-type'); }
-  validate(value, path) {
-    if (!value.localizations) return [];
-    const errors = [];
-    for (const [lang, lc] of Object.entries(value.localizations)) {
-      for (let i = 0; i < (lc.terms?.length ?? 0); i++) {
-        const t = lc.terms[i];
-        if (t.type && !VALID_DESIGNATION_TYPES.has(t.type)) {
-          errors.push(...this.error(`${path}localizations.${lang}.terms[${i}].type`,
-            `Unknown designation type '${t.type}'`));
+  validate(concept, path, result) {
+    for (const lang of _langs(concept)) {
+      const lc = _loc(concept, 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);
+        if (type && !VALID_DESIGNATION_TYPES.has(type)) {
+          result.addError(`${path}localizations.${lang}.terms[${i}].type`,
+            `Unknown designation type '${type}'`);
         }
       }
     }
-    return errors;
   }
 }
 
 export class EntryStatusRule extends ValidationRule {
   constructor() { super('entry-status'); }
-  validate(value, path) {
-    if (!value.localizations) return [];
-    const errors = [];
-    for (const [lang, lc] of Object.entries(value.localizations)) {
-      if (lc.entry_status && !VALID_ENTRY_STATUSES.has(lc.entry_status)) {
-        errors.push(...this.error(`${path}localizations.${lang}.entry_status`,
-          `Unknown entry status '${lc.entry_status}'`));
+  validate(concept, path, result) {
+    for (const lang of _langs(concept)) {
+      const lc = _loc(concept, 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}'`);
       }
     }
-    return errors;
   }
 }
 
@@ -66,34 +70,37 @@ export class ConceptValidator {
   }
 
   validate(concept) {
-    const errors = [];
-    const json = typeof concept.toJSON === 'function' ? concept.toJSON() : concept;
+    const result = new ValidationResult();
+    const hasModelApi = typeof concept.localization === 'function';
 
-    if (!json.id) {
-      errors.push(new ValidationError('id', 'Concept must have an id'));
+    if (!concept.id) {
+      result.addError('id', 'Concept must have an id');
     }
-    if (!json.localizations || Object.keys(json.localizations).length === 0) {
-      errors.push(new ValidationError('localizations',
-        'Concept must have at least one localization', 'warning'));
+
+    const langs = hasModelApi ? concept.languages : Object.keys(concept.localizations ?? {});
+    if (langs.length === 0) {
+      result.addWarning('localizations', 'Concept must have at least one localization');
+    } else if (hasModelApi) {
+      for (const lang of langs) {
+        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(json.localizations)) {
+      for (const [lang, lc] of Object.entries(concept.localizations ?? {})) {
         if (!lc.terms || lc.terms.length === 0) {
-          errors.push(new ValidationError(
-            `localizations.${lang}.terms`,
-            `Localization '${lang}' must have at least one term`, 'warning'));
+          result.addWarning(`localizations.${lang}.terms`,
+            `Localization '${lang}' must have at least one term`);
         }
       }
     }
 
     for (const rule of this._rules) {
-      errors.push(...rule.validate(json, ''));
+      rule.validate(concept, '', result);
     }
 
-    return {
-      valid: errors.filter(e => e.severity === 'error').length === 0,
-      errors: errors.filter(e => e.severity === 'error'),
-      warnings: errors.filter(e => e.severity === 'warning'),
-    };
+    return result;
   }
 }
-

package/src/validators/gcr-validator.js

@@ -12,7 +12,7 @@ export class GcrValidator {
   }
 
   async _validateMetadata(pkg, result) {
-    const raw = await pkg._readText('metadata.yaml');
+    const raw = await pkg.readText('metadata.yaml');
     if (!raw) {
       result.addError('metadata.yaml is missing');
       return;
@@ -49,7 +49,7 @@ export class GcrValidator {
   }
 
   async _validateFileAsset(pkg, path, result) {
-    const raw = await pkg._readText(path);
+    const raw = await pkg.readText(path);
     if (!raw) return;
     try {
       yaml.load(raw);
@@ -58,15 +58,15 @@ export class GcrValidator {
     }
   }
 
-  async _validateDirectoryAsset(pkg, dirPath, result) {
+  _validateDirectoryAsset(pkg, dirPath, result) {
     let hasFiles = false;
     let hasEntries = false;
-    pkg._zip.forEach((relativePath, entry) => {
-      if (relativePath.startsWith(`${dirPath}/`)) {
+    for (const entry of pkg.entryPaths()) {
+      if (entry.path.startsWith(`${dirPath}/`)) {
         hasEntries = true;
         if (!entry.dir) hasFiles = true;
       }
-    });
+    }
     if (hasEntries && !hasFiles) {
       result.addWarning(`${dirPath}/ directory exists but is empty`);
     }

package/src/validators/index.js

@@ -13,6 +13,7 @@ export {
   DomainRefRule,
   UuidFormatRule,
   SourceUrnFormatRule,
+  CiteRefIntegrityRule,
 } from './v3-rules.js';
 
 import { ConceptValidator, LanguageCodeRule, DesignationTypeRule, EntryStatusRule } from './concept-validator.js';
@@ -27,6 +28,7 @@ import {
   DomainRefRule,
   UuidFormatRule,
   SourceUrnFormatRule,
+  CiteRefIntegrityRule,
 } from './v3-rules.js';
 
 const _default = new ConceptValidator()
@@ -40,7 +42,8 @@ const _default = new ConceptValidator()
   .addRule(new DomainRefRule())
   .addRule(new UuidFormatRule())
   .addRule(new SourceUrnFormatRule())
-  .addRule(new RelationshipTypeRule());
+  .addRule(new RelationshipTypeRule())
+  .addRule(new CiteRefIntegrityRule());
 
 export function validateConcept(concept) {
   return _default.validate(concept);

package/src/validators/register-validator.js

@@ -1,22 +1,18 @@
-import { ValidationError } from './validation-error.js';
+import { ValidationResult } from './validation-result.js';
 
 export class RegisterValidator {
   validate(register) {
-    const errors = [];
+    const result = new ValidationResult();
     if (!register || typeof register !== 'object') {
-      errors.push(new ValidationError('', 'Register must be a non-null object'));
-      return { valid: false, errors, warnings: [] };
+      result.addError('', 'Register must be a non-null object');
+      return result;
     }
     if (!register.schema_version) {
-      errors.push(new ValidationError('schema_version', 'Register must have a schema_version', 'warning'));
+      result.addWarning('schema_version', 'Register must have a schema_version');
     }
     if (!register.shortname) {
-      errors.push(new ValidationError('shortname', 'Register should have a shortname', 'warning'));
+      result.addWarning('shortname', 'Register should have a shortname');
     }
-    return {
-      valid: errors.filter(e => e.severity === 'error').length === 0,
-      errors: errors.filter(e => e.severity === 'error'),
-      warnings: errors.filter(e => e.severity === 'warning'),
-    };
+    return result;
   }
 }

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

@@ -8,32 +8,31 @@ const KNOWN_DESIGNATION_TYPES = new Set(DESIGNATION_RELATIONSHIP_TYPES);
 export class RelationshipTypeRule extends ValidationRule {
   constructor() { super('relationship-type', 'warning'); }
 
-  validate(value, path) {
-    const errors = [];
-    this._checkRelated(value.related, `${path}related`, KNOWN_CONCEPT_TYPES, errors);
+  validate(concept, path, result) {
+    const related = concept.relatedConcepts ?? concept.related ?? [];
+    this._checkRelated(related, `${path}related`, KNOWN_CONCEPT_TYPES, result);
 
-    if (value.localizations) {
-      for (const [lang, lc] of Object.entries(value.localizations)) {
-        this._checkRelated(lc.related, `${path}localizations.${lang}.related`, KNOWN_CONCEPT_TYPES, errors);
+    const langs = concept.languages ?? [];
+    for (const lang of langs) {
+      const lc = concept.localization?.(lang);
+      if (!lc) continue;
 
-        if (lc.terms) {
-          for (let ti = 0; ti < lc.terms.length; ti++) {
-            this._checkRelated(lc.terms[ti]?.related,
-              `${path}localizations.${lang}.terms[${ti}].related`, KNOWN_DESIGNATION_TYPES, errors);
-          }
-        }
+      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);
       }
     }
-    return errors;
   }
 
-  _checkRelated(arr, basePath, knownTypes, errors) {
+  _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)) {
-        errors.push(...this.error(`${basePath}[${i}].type`,
-          `Unknown relationship type '${type}'`));
+        this.addIssue(result, `${basePath}[${i}].type`,
+          `Unknown relationship type '${type}'`);
       }
     }
   }