glossarist 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "JavaScript SDK for Glossarist GCR packages — read, write, validate, and manage terminology concepts",
   "type": "module",
   "main": "src/index.js",

package/src/concept-collection.js

@@ -37,8 +37,7 @@ export class ConceptCollection {
 
   byStatus(status) {
     return new ConceptCollection(this[_items].filter(c => {
-      const langs = c.languages;
-      return langs.length > 0 && c.localization(langs[0])?.entryStatus === status;
+      return c.languages.some(lang => c.localization(lang)?.entryStatus === status);
     }));
   }
 

package/src/concept-parser.js

@@ -70,6 +70,8 @@ export class ConceptParser {
       id: String(mc.data.identifier),
       term: null,
       localizations,
+      domains: mc.data.domains,
+      groups: mc.data.groups,
       raw: mc,
     });
   }

package/src/concept-serializer.js

@@ -39,6 +39,10 @@ export class ConceptSerializer {
       id: genId(),
     };
 
+    if (concept.domains.length > 0) {
+      mainDoc.data.domains = concept.domains.map(d => d.toJSON());
+    }
+
     const parts = [
       '---\n' + yaml.dump(mainDoc, DUMP_OPTS),
       ...langDocs.map(d => '---\n' + yaml.dump(d, DUMP_OPTS)),

package/src/index.d.ts

@@ -26,7 +26,7 @@ export { ConceptCollection } from './concept-collection';
 export { ManagedConceptCollection } from './managed-concept-collection';
 
 // Validators
-export { validateConcept, validateRegister, createConceptValidator, ValidationError, ValidationRule, RegisterValidator } from './validators/index';
+export { validateConcept, validateRegister, validateGcrPackage, createConceptValidator, ValidationError, ValidationRule, ValidationResult, RegisterValidator, GcrValidator } from './validators/index';
 
 // UUID
 export { conceptUuid, localizedConceptUuid, uuidV5 } from './uuid';

package/src/index.js

@@ -5,7 +5,7 @@ export { writeConcept, writeConcepts } from './concept-writer.js';
 export { createGcr, GcrWriter } from './gcr-writer.js';
 export { ConceptCollection } from './concept-collection.js';
 export { ManagedConceptCollection } from './managed-concept-collection.js';
-export { validateConcept, validateRegister, createConceptValidator, ValidationError, ValidationRule, RegisterValidator } from './validators/index.js';
+export { validateConcept, validateRegister, validateGcrPackage, createConceptValidator, ValidationError, ValidationRule, ValidationResult, RegisterValidator, GcrValidator } from './validators/index.js';
 export { conceptUuid, localizedConceptUuid, uuidV5 } from './uuid.js';
 export { ReferenceResolver, Reference, referenceResolver } from './reference-resolver.js';
 export { V1Reader, migrateV1ToV2 } from './v1-reader.js';
@@ -30,7 +30,7 @@ export {
   GlossaristModel,
   Concept, LocalizedConcept,
   Designation, Expression, Abbreviation, Symbol, GraphicalSymbol,
-  Citation, ConceptSource, RelatedConcept, ConceptDate,
+  Citation, ConceptSource, RelatedConcept, ConceptReference, ConceptDate,
   DetailedDefinition, NonVerbRep,
   GcrMetadata, GcrStatistics,
   RELATIONSHIP_TYPES, DATE_TYPES,

package/src/models/concept-reference.js

@@ -0,0 +1,36 @@
+import { GlossaristModel } from './base.js';
+
+export class ConceptReference extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.conceptId = data.concept_id ?? data.conceptId ?? null;
+    this.refType = data.ref_type ?? data.refType ?? null;
+    this.source = data.source ?? null;
+    this.urn = data.urn ?? null;
+  }
+
+  get isLocal() {
+    return this.urn == null && this.source == null;
+  }
+
+  get isExternal() {
+    return !this.isLocal;
+  }
+
+  static domain(conceptId) {
+    return new ConceptReference({ concept_id: conceptId, ref_type: 'domain' });
+  }
+
+  toJSON() {
+    const obj = {};
+    if (this.conceptId != null) obj.concept_id = this.conceptId;
+    if (this.refType != null) obj.ref_type = this.refType;
+    if (this.source != null) obj.source = this.source;
+    if (this.urn != null) obj.urn = this.urn;
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new ConceptReference(data);
+  }
+}

package/src/models/concept.js

@@ -1,6 +1,7 @@
 import { GlossaristModel } from './base.js';
 import { LocalizedConcept } from './localized-concept.js';
 import { RelatedConcept } from './related-concept.js';
+import { ConceptReference } from './concept-reference.js';
 import { ConceptDate } from './concept-date.js';
 import { ConceptSource } from './concept-source.js';
 
@@ -13,6 +14,7 @@ export class Concept extends GlossaristModel {
     this._cache = {};
 
     this.relatedConcepts = _mapInstances(data.relatedConcepts ?? data.related_concepts ?? [], RelatedConcept);
+    this.domains = _normalizeDomains(data.domains, data.groups);
     this.dates = _mapInstances(data.dates ?? [], ConceptDate);
     this.sources = _mapInstances(data.sources ?? [], ConceptSource);
     this.status = data.status ?? null;
@@ -84,6 +86,9 @@ export class Concept extends GlossaristModel {
     if (this.relatedConcepts.length > 0) {
       obj.relatedConcepts = this.relatedConcepts.map(rc => rc.toJSON());
     }
+    if (this.domains.length > 0) {
+      obj.domains = this.domains.map(d => d.toJSON());
+    }
     if (this.dates.length > 0) {
       obj.dates = this.dates.map(d => d.toJSON());
     }
@@ -102,3 +107,15 @@ export class Concept extends GlossaristModel {
 function _mapInstances(arr, Cls) {
   return arr.map(item => item instanceof Cls ? item : new Cls(item));
 }
+
+function _normalizeDomains(domains, groups) {
+  if (domains) {
+    return domains.map(d => d instanceof ConceptReference ? d : new ConceptReference(d));
+  }
+  if (groups) {
+    return groups.map(g => typeof g === 'string'
+      ? ConceptReference.domain(g)
+      : new ConceptReference(g));
+  }
+  return [];
+}

package/src/models/index.d.ts

@@ -13,6 +13,7 @@ export class Concept extends GlossaristModel {
   readonly localizations: Record<string, any>;
   readonly raw: Record<string, unknown> | null;
   readonly relatedConcepts: RelatedConcept[];
+  readonly domains: ConceptReference[];
   readonly dates: ConceptDate[];
   readonly sources: ConceptSource[];
   readonly status: string | null;
@@ -34,6 +35,7 @@ export class LocalizedConcept extends GlossaristModel {
   readonly examples: { content: string }[];
   readonly sources: ConceptSource[];
   readonly entryStatus: string | null;
+  readonly domain: string | null;
   readonly primaryDesignation: string | null;
   readonly primaryDefinition: string | null;
   static fromJSON(data: Record<string, unknown>): LocalizedConcept;
@@ -88,6 +90,17 @@ export class RelatedConcept extends GlossaristModel {
   readonly ref: Citation | null;
 }
 
+export class ConceptReference extends GlossaristModel {
+  readonly conceptId: string | null;
+  readonly refType: string | null;
+  readonly source: string | null;
+  readonly urn: string | null;
+  readonly isLocal: boolean;
+  readonly isExternal: boolean;
+  static domain(conceptId: string): ConceptReference;
+  static fromJSON(data: Record<string, unknown>): ConceptReference;
+}
+
 export const DATE_TYPES: readonly string[];
 export class ConceptDate extends GlossaristModel {
   readonly date: string | null;

package/src/models/index.js

@@ -5,6 +5,7 @@ export { Designation, Expression, Abbreviation, Symbol, GraphicalSymbol } from '
 export { Citation } from './citation.js';
 export { ConceptSource } from './concept-source.js';
 export { RelatedConcept, RELATIONSHIP_TYPES } from './related-concept.js';
+export { ConceptReference } from './concept-reference.js';
 export { ConceptDate, DATE_TYPES } from './concept-date.js';
 export { DetailedDefinition } from './detailed-definition.js';
 export { NonVerbRep } from './non-verb-rep.js';

package/src/models/localized-concept.js

@@ -15,6 +15,7 @@ export class LocalizedConcept extends GlossaristModel {
     this.entryStatus = data.entry_status ?? data.entryStatus ?? null;
     this.reviewType = data.review_type ?? data.reviewType ?? null;
     this.classification = data.classification ?? null;
+    this.domain = data.domain ?? null;
 
     this._terms = null;
     this._definitions = null;
@@ -83,6 +84,7 @@ export class LocalizedConcept extends GlossaristModel {
     if (this.entryStatus != null) obj.entry_status = this.entryStatus;
     if (this.reviewType != null) obj.review_type = this.reviewType;
     if (this.classification != null) obj.classification = this.classification;
+    if (this.domain != null) obj.domain = this.domain;
     return obj;
   }
 

package/src/validators/gcr-validator.js

@@ -0,0 +1,74 @@
+import yaml from 'js-yaml';
+import { DATASET_ASSETS } from '../dataset-asset.js';
+import { ValidationResult } from './validation-result.js';
+
+export class GcrValidator {
+  async validate(pkg) {
+    const result = new ValidationResult();
+    await this._validateMetadata(pkg, result);
+    await this._validateConcepts(pkg, result);
+    await this._validateAssets(pkg, result);
+    return result;
+  }
+
+  async _validateMetadata(pkg, result) {
+    const raw = await pkg._readText('metadata.yaml');
+    if (!raw) {
+      result.addError('metadata.yaml is missing');
+      return;
+    }
+
+    let meta;
+    try {
+      meta = yaml.load(raw);
+    } catch (e) {
+      result.addError(`metadata.yaml: invalid YAML: ${e.message}`);
+      return;
+    }
+
+    if (!meta.shortname) result.addError('metadata.yaml missing shortname');
+    if (!meta.version) result.addError('metadata.yaml missing version');
+    if (meta.concept_count == null) result.addError('metadata.yaml missing concept_count');
+  }
+
+  async _validateConcepts(pkg, result) {
+    const ids = await pkg.conceptIds();
+    if (ids.length === 0) {
+      result.addError('No concept files found in concepts/');
+    }
+  }
+
+  async _validateAssets(pkg, result) {
+    for (const asset of DATASET_ASSETS) {
+      if (asset.type === 'file') {
+        await this._validateFileAsset(pkg, asset.path, result);
+      } else if (asset.type === 'directory') {
+        await this._validateDirectoryAsset(pkg, asset.path, result);
+      }
+    }
+  }
+
+  async _validateFileAsset(pkg, path, result) {
+    const raw = await pkg._readText(path);
+    if (!raw) return;
+    try {
+      yaml.load(raw);
+    } catch (e) {
+      result.addError(`${path}: invalid YAML at line ${e.mark?.line ?? '?'}: ${e.message}`);
+    }
+  }
+
+  async _validateDirectoryAsset(pkg, dirPath, result) {
+    let hasFiles = false;
+    let hasEntries = false;
+    pkg._zip.forEach((relativePath, entry) => {
+      if (relativePath.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

@@ -1,10 +1,13 @@
 export { ValidationError } from './validation-error.js';
 export { ValidationRule } from './validation-rule.js';
+export { ValidationResult } from './validation-result.js';
 export { ConceptValidator, LanguageCodeRule, DesignationTypeRule, EntryStatusRule } from './concept-validator.js';
 export { RegisterValidator } from './register-validator.js';
+export { GcrValidator } from './gcr-validator.js';
 
 import { ConceptValidator, LanguageCodeRule, DesignationTypeRule, EntryStatusRule } from './concept-validator.js';
 import { RegisterValidator } from './register-validator.js';
+import { GcrValidator } from './gcr-validator.js';
 
 const _default = new ConceptValidator()
   .addRule(new LanguageCodeRule())
@@ -22,3 +25,7 @@ export function createConceptValidator() {
 export function validateRegister(register) {
   return new RegisterValidator().validate(register);
 }
+
+export async function validateGcrPackage(pkg) {
+  return new GcrValidator().validate(pkg);
+}

package/src/validators/validation-result.js

@@ -0,0 +1,34 @@
+export class ValidationResult {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+  }
+
+  get valid() {
+    return this.errors.length === 0;
+  }
+
+  addError(message) {
+    this.errors.push(message);
+    return this;
+  }
+
+  addWarning(message) {
+    this.warnings.push(message);
+    return this;
+  }
+
+  merge(other) {
+    for (const e of other.errors) this.errors.push(e);
+    for (const w of other.warnings) this.warnings.push(w);
+    return this;
+  }
+
+  toJSON() {
+    return {
+      valid: this.valid,
+      errors: [...this.errors],
+      warnings: [...this.warnings],
+    };
+  }
+}