glossarist 0.1.1 → 0.1.2

package/src/models/base.js

@@ -0,0 +1,18 @@
+export class GlossaristModel {
+  toJSON() {
+    throw new Error(`${this.constructor.name} must implement toJSON()`);
+  }
+
+  static fromJSON() {
+    throw new Error(`${this.name} must implement fromJSON()`);
+  }
+
+  equals(other) {
+    if (!(other instanceof this.constructor)) return false;
+    return JSON.stringify(this.toJSON()) === JSON.stringify(other.toJSON());
+  }
+
+  clone() {
+    return this.constructor.fromJSON(JSON.parse(JSON.stringify(this.toJSON())));
+  }
+}

package/src/models/citation.js

@@ -0,0 +1,45 @@
+import { GlossaristModel } from './base.js';
+
+export class Citation extends GlossaristModel {
+  constructor(data) {
+    super();
+    if (typeof data === 'string') {
+      this.source = data;
+      this.ref = null;
+      this.id = null;
+      this.version = null;
+      this.clause = null;
+      this.link = null;
+    } else {
+      const d = data ?? {};
+      this.source = d.source ?? null;
+      this.ref = d.ref ?? null;
+      this.id = d.id ?? null;
+      this.version = d.version ?? null;
+      this.clause = d.clause ?? null;
+      this.link = d.link ?? null;
+    }
+  }
+
+  toString() {
+    if (this.ref) return this.ref;
+    if (typeof this.source === 'string') return this.source;
+    if (typeof this.source === 'object' && this.source !== null) return this.source.ref ?? '';
+    return '';
+  }
+
+  toJSON() {
+    const obj = {};
+    if (this.source != null) obj.source = this.source;
+    if (this.ref != null) obj.ref = this.ref;
+    if (this.id != null) obj.id = this.id;
+    if (this.version != null) obj.version = this.version;
+    if (this.clause != null) obj.clause = this.clause;
+    if (this.link != null) obj.link = this.link;
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new Citation(data);
+  }
+}

package/src/models/concept-date.js

@@ -0,0 +1,28 @@
+import { GlossaristModel } from './base.js';
+
+export const DATE_TYPES = Object.freeze([
+  'accepted', 'amended', 'published', 'withdrawn', 'created',
+]);
+
+export class ConceptDate extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.date = data.date ?? null;
+    this.type = data.type ?? null;
+  }
+
+  get parsedDate() {
+    return this.date ? new Date(this.date) : null;
+  }
+
+  toJSON() {
+    const obj = {};
+    if (this.date != null) obj.date = this.date;
+    if (this.type != null) obj.type = this.type;
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new ConceptDate(data);
+  }
+}

package/src/models/concept-source.js

@@ -0,0 +1,27 @@
+import { GlossaristModel } from './base.js';
+import { Citation } from './citation.js';
+
+export class ConceptSource extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.status = data.status ?? null;
+    this.type = data.type ?? null;
+    this.origin = data.origin
+      ? (data.origin instanceof Citation ? data.origin : new Citation(data.origin))
+      : null;
+    this.modification = data.modification ?? null;
+  }
+
+  toJSON() {
+    const obj = {};
+    if (this.status != null) obj.status = this.status;
+    if (this.type != null) obj.type = this.type;
+    if (this.origin != null) obj.origin = this.origin.toJSON();
+    if (this.modification != null) obj.modification = this.modification;
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new ConceptSource(data);
+  }
+}

package/src/models/concept.js

@@ -0,0 +1,104 @@
+import { GlossaristModel } from './base.js';
+import { LocalizedConcept } from './localized-concept.js';
+import { RelatedConcept } from './related-concept.js';
+import { ConceptDate } from './concept-date.js';
+import { ConceptSource } from './concept-source.js';
+
+export class Concept extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.id = String(data.id ?? data.termid ?? '');
+    this.term = data.term ?? null;
+    this._rawLocalizations = data.localizations ?? {};
+    this._cache = {};
+
+    this.relatedConcepts = _mapInstances(data.relatedConcepts ?? data.related_concepts ?? [], RelatedConcept);
+    this.dates = _mapInstances(data.dates ?? [], ConceptDate);
+    this.sources = _mapInstances(data.sources ?? [], ConceptSource);
+    this.status = data.status ?? null;
+    this.raw = data.raw ?? null;
+  }
+
+  get termid() { return this.id; }
+
+  get languages() {
+    return Object.keys(this._rawLocalizations);
+  }
+
+  get localizations() {
+    return this._rawLocalizations;
+  }
+
+  localization(lang) {
+    if (!(lang in this._rawLocalizations)) return undefined;
+    if (!this._cache[lang]) {
+      const raw = this._rawLocalizations[lang];
+      this._cache[lang] = new LocalizedConcept({ ...raw, language_code: lang });
+    }
+    return this._cache[lang];
+  }
+
+  primaryDesignation(lang) {
+    return this.localization(lang)?.primaryDesignation ?? null;
+  }
+
+  definition(lang) {
+    return this.localization(lang)?.primaryDefinition ?? null;
+  }
+
+  setLocalization(lang, lc) {
+    if (lc instanceof LocalizedConcept) {
+      this._cache[lang] = lc;
+      const json = lc.toJSON();
+      delete json.language_code;
+      this._rawLocalizations[lang] = json;
+    } else {
+      this._rawLocalizations[lang] = lc;
+      delete this._cache[lang];
+    }
+    return this;
+  }
+
+  hasLocalization(lang) {
+    return lang in this._rawLocalizations;
+  }
+
+  toJSON() {
+    const obj = { id: this.id };
+    if (this.term != null) obj.term = this.term;
+
+    if (Object.keys(this._rawLocalizations).length > 0) {
+      obj.localizations = {};
+      for (const lang of this.languages) {
+        const lc = this.localization(lang);
+        if (lc) {
+          const json = lc.toJSON();
+          delete json.language_code;
+          obj.localizations[lang] = json;
+        }
+      }
+    } else {
+      obj.localizations = {};
+    }
+
+    if (this.relatedConcepts.length > 0) {
+      obj.relatedConcepts = this.relatedConcepts.map(rc => rc.toJSON());
+    }
+    if (this.dates.length > 0) {
+      obj.dates = this.dates.map(d => d.toJSON());
+    }
+    if (this.sources.length > 0) {
+      obj.sources = this.sources.map(s => s.toJSON());
+    }
+    if (this.status != null) obj.status = this.status;
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new Concept(data);
+  }
+}
+
+function _mapInstances(arr, Cls) {
+  return arr.map(item => item instanceof Cls ? item : new Cls(item));
+}

package/src/models/designation.js

@@ -0,0 +1,96 @@
+import { GlossaristModel } from './base.js';
+
+export class Designation extends GlossaristModel {
+  static _registry = new Map();
+
+  static register(type, cls) {
+    Designation._registry.set(type, cls);
+  }
+
+  static fromData(data) {
+    if (data instanceof Designation) return data;
+    const Cls = Designation._registry.get(data?.type) ?? Designation;
+    return new Cls(data);
+  }
+
+  constructor(data = {}) {
+    super();
+    this.designation = data.designation ?? '';
+    this.type = data.type ?? 'expression';
+    this.normativeStatus = data.normative_status ?? null;
+  }
+
+  toJSON() {
+    const obj = { type: this.type, designation: this.designation };
+    if (this.normativeStatus != null) obj.normative_status = this.normativeStatus;
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return Designation.fromData(data);
+  }
+}
+
+export class Expression extends Designation {
+  constructor(data = {}) {
+    super(data);
+    this.gender = data.gender ?? null;
+    this.plurality = data.plurality ?? null;
+    this.partOfSpeech = data.part_of_speech ?? null;
+    this.geographicalArea = data.geographical_area ?? null;
+  }
+
+  toJSON() {
+    const obj = super.toJSON();
+    if (this.gender != null) obj.gender = this.gender;
+    if (this.plurality != null) obj.plurality = this.plurality;
+    if (this.partOfSpeech != null) obj.part_of_speech = this.partOfSpeech;
+    if (this.geographicalArea != null) obj.geographical_area = this.geographicalArea;
+    return obj;
+  }
+
+  static fromJSON(data) { return new Expression(data); }
+}
+
+Designation.register('expression', Expression);
+
+export class Abbreviation extends Designation {
+  static fromJSON(data) { return new Abbreviation(data); }
+}
+
+Designation.register('abbreviation', Abbreviation);
+
+export class Symbol extends Designation {
+  constructor(data = {}) {
+    super(data);
+    this.international = data.international ?? null;
+  }
+
+  toJSON() {
+    const obj = super.toJSON();
+    if (this.international != null) obj.international = this.international;
+    return obj;
+  }
+
+  static fromJSON(data) { return new Symbol(data); }
+}
+
+Designation.register('symbol', Symbol);
+
+export class GraphicalSymbol extends Designation {
+  constructor(data = {}) {
+    super(data);
+    this.image = data.image ?? null;
+  }
+
+  toJSON() {
+    const obj = super.toJSON();
+    if (this.image != null) obj.image = this.image;
+    return obj;
+  }
+
+  static fromJSON(data) { return new GraphicalSymbol(data); }
+}
+
+Designation.register('graphical symbol', GraphicalSymbol);
+Designation.register('graphical_symbol', GraphicalSymbol);

package/src/models/detailed-definition.js

@@ -0,0 +1,24 @@
+import { GlossaristModel } from './base.js';
+import { Citation } from './citation.js';
+
+export class DetailedDefinition extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.content = data.content ?? '';
+    this.sources = (data.sources ?? []).map(
+      s => s instanceof Citation ? s : new Citation(s)
+    );
+  }
+
+  toJSON() {
+    const obj = { content: this.content };
+    if (this.sources.length > 0) {
+      obj.sources = this.sources.map(s => s.toJSON());
+    }
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new DetailedDefinition(data);
+  }
+}

package/src/models/index.d.ts

@@ -0,0 +1,107 @@
+export class GlossaristModel {
+  toJSON(): Record<string, unknown>;
+  static fromJSON(data: Record<string, unknown>): GlossaristModel;
+  equals(other: GlossaristModel): boolean;
+  clone(): GlossaristModel;
+}
+
+export class Concept extends GlossaristModel {
+  readonly id: string;
+  readonly term: string | null;
+  readonly termid: string;
+  readonly languages: string[];
+  readonly localizations: Record<string, any>;
+  readonly raw: Record<string, unknown> | null;
+  readonly relatedConcepts: RelatedConcept[];
+  readonly dates: ConceptDate[];
+  readonly sources: ConceptSource[];
+  readonly status: string | null;
+
+  localization(lang: string): LocalizedConcept | undefined;
+  primaryDesignation(lang: string): string | null;
+  definition(lang: string): string | null;
+  setLocalization(lang: string, lc: LocalizedConcept | Record<string, unknown>): this;
+  hasLocalization(lang: string): boolean;
+  static fromJSON(data: Record<string, unknown>): Concept;
+}
+
+export class LocalizedConcept extends GlossaristModel {
+  readonly languageCode: string | null;
+  readonly terms: Designation[];
+  readonly definitions: DetailedDefinition[];
+  readonly definition: DetailedDefinition[];
+  readonly notes: { content: string }[];
+  readonly examples: { content: string }[];
+  readonly sources: ConceptSource[];
+  readonly entryStatus: string | null;
+  readonly primaryDesignation: string | null;
+  readonly primaryDefinition: string | null;
+  static fromJSON(data: Record<string, unknown>): LocalizedConcept;
+}
+
+export class Designation extends GlossaristModel {
+  readonly designation: string;
+  readonly type: string;
+  readonly normativeStatus: string | null;
+  static register(type: string, cls: typeof Designation): void;
+  static fromData(data: Record<string, unknown>): Designation;
+  static fromJSON(data: Record<string, unknown>): Designation;
+}
+
+export class Expression extends Designation {
+  readonly gender: string | null;
+  readonly plurality: string | null;
+  readonly partOfSpeech: string | null;
+  readonly geographicalArea: string | null;
+}
+
+export class Abbreviation extends Designation {}
+export class Symbol extends Designation {
+  readonly international: string | null;
+}
+export class GraphicalSymbol extends Designation {
+  readonly image: string | null;
+}
+
+export class Citation extends GlossaristModel {
+  readonly source: string | Record<string, unknown> | null;
+  readonly ref: string | null;
+  readonly id: string | null;
+  readonly version: string | null;
+  readonly clause: string | null;
+  readonly link: string | null;
+  toString(): string;
+}
+
+export class ConceptSource extends GlossaristModel {
+  readonly status: string | null;
+  readonly type: string | null;
+  readonly origin: Citation | null;
+  readonly modification: string | null;
+}
+
+export const RELATIONSHIP_TYPES: readonly string[];
+export class RelatedConcept extends GlossaristModel {
+  readonly type: string;
+  readonly content: string | null;
+  readonly ref: Citation | null;
+}
+
+export const DATE_TYPES: readonly string[];
+export class ConceptDate extends GlossaristModel {
+  readonly date: string | null;
+  readonly type: string | null;
+  readonly parsedDate: Date | null;
+}
+
+export class DetailedDefinition extends GlossaristModel {
+  readonly content: string;
+  readonly sources: Citation[];
+}
+
+export class NonVerbRep extends GlossaristModel {
+  readonly image: string | null;
+  readonly table: string | null;
+  readonly formula: string | null;
+  readonly sources: Citation[];
+}

package/src/models/index.js

@@ -0,0 +1,10 @@
+export { GlossaristModel } from './base.js';
+export { Concept } from './concept.js';
+export { LocalizedConcept } from './localized-concept.js';
+export { Designation, Expression, Abbreviation, Symbol, GraphicalSymbol } from './designation.js';
+export { Citation } from './citation.js';
+export { ConceptSource } from './concept-source.js';
+export { RelatedConcept, RELATIONSHIP_TYPES } from './related-concept.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

@@ -0,0 +1,92 @@
+import { GlossaristModel } from './base.js';
+import { Designation } from './designation.js';
+import { DetailedDefinition } from './detailed-definition.js';
+import { ConceptSource } from './concept-source.js';
+
+export class LocalizedConcept extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.languageCode = data.language_code ?? data.languageCode ?? null;
+    this._rawTerms = data.terms ?? [];
+    this._rawDefinition = data.definition ?? [];
+    this._rawSources = data.sources ?? [];
+    this.notes = data.notes ?? [];
+    this.examples = data.examples ?? [];
+    this.entryStatus = data.entry_status ?? data.entryStatus ?? null;
+    this.reviewType = data.review_type ?? data.reviewType ?? null;
+    this.classification = data.classification ?? null;
+
+    this._terms = null;
+    this._definitions = null;
+    this._sources = null;
+  }
+
+  get terms() {
+    if (this._terms === null) {
+      this._terms = this._rawTerms.map(t => Designation.fromData(t));
+    }
+    return this._terms;
+  }
+
+  get definitions() {
+    if (this._definitions === null) {
+      this._definitions = this._rawDefinition.map(
+        d => d instanceof DetailedDefinition ? d : new DetailedDefinition(d)
+      );
+    }
+    return this._definitions;
+  }
+
+  get definition() {
+    return this.definitions;
+  }
+
+  get sources() {
+    if (this._sources === null) {
+      this._sources = this._rawSources.map(
+        s => s instanceof ConceptSource ? s : new ConceptSource(s)
+      );
+    }
+    return this._sources;
+  }
+
+  get primaryDesignation() {
+    return this.terms[0]?.designation ?? null;
+  }
+
+  get primaryDefinition() {
+    return this.definitions[0]?.content ?? null;
+  }
+
+  toJSON() {
+    const obj = {};
+    if (this.languageCode) obj.language_code = this.languageCode;
+
+    const terms = this._terms ?? this._rawTerms;
+    if (terms.length > 0) {
+      obj.terms = terms.map(t => (typeof t.toJSON === 'function') ? t.toJSON() : t);
+    }
+
+    const defs = this._definitions ?? (this._rawDefinition.length > 0 ? this._rawDefinition : []);
+    if (defs.length > 0) {
+      obj.definition = defs.map(d => (typeof d.toJSON === 'function') ? d.toJSON() : d);
+    }
+
+    if (this.notes.length > 0) obj.notes = this.notes;
+    if (this.examples.length > 0) obj.examples = this.examples;
+
+    const sources = this._sources ?? (this._rawSources.length > 0 ? this._rawSources : []);
+    if (sources.length > 0) {
+      obj.sources = sources.map(s => (typeof s.toJSON === 'function') ? s.toJSON() : s);
+    }
+
+    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;
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new LocalizedConcept(data);
+  }
+}

package/src/models/non-verb-rep.js

@@ -0,0 +1,27 @@
+import { GlossaristModel } from './base.js';
+import { Citation } from './citation.js';
+
+export class NonVerbRep extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.image = data.image ?? null;
+    this.table = data.table ?? null;
+    this.formula = data.formula ?? null;
+    this.sources = (data.sources ?? []).map(
+      s => s instanceof Citation ? s : new Citation(s)
+    );
+  }
+
+  toJSON() {
+    const obj = {};
+    if (this.image != null) obj.image = this.image;
+    if (this.table != null) obj.table = this.table;
+    if (this.formula != null) obj.formula = this.formula;
+    if (this.sources.length > 0) obj.sources = this.sources.map(s => s.toJSON());
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new NonVerbRep(data);
+  }
+}

package/src/models/related-concept.js

@@ -0,0 +1,30 @@
+import { GlossaristModel } from './base.js';
+import { Citation } from './citation.js';
+
+export const RELATIONSHIP_TYPES = Object.freeze([
+  'supersedes', 'superseded_by', 'extends', 'extended_by',
+  'narrower', 'broader', 'equivalent', 'compare', 'contrast',
+  'derived', 'deprecated', 'related',
+]);
+
+export class RelatedConcept extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.type = data.type ?? 'related';
+    this.content = data.content ?? null;
+    this.ref = data.ref
+      ? (data.ref instanceof Citation ? data.ref : new Citation(data.ref))
+      : null;
+  }
+
+  toJSON() {
+    const obj = { type: this.type };
+    if (this.content != null) obj.content = this.content;
+    if (this.ref != null) obj.ref = this.ref.toJSON();
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new RelatedConcept(data);
+  }
+}

package/src/reference-resolver.js

@@ -0,0 +1,78 @@
+export class Reference {
+  constructor(type, target, relationship, source) {
+    this.type = type;
+    this.target = target;
+    this.relationship = relationship ?? null;
+    this.source = source ?? null;
+  }
+}
+
+export class ReferenceResolver {
+  extractReferences(concept) {
+    const refs = [];
+
+    for (const rc of concept.relatedConcepts) {
+      const target = rc.content ?? rc.ref?.toString() ?? '';
+      if (target) {
+        refs.push(new Reference('concept', target, rc.type, 'relatedConcepts'));
+      }
+    }
+
+    for (const lang of concept.languages) {
+      const lc = concept.localization(lang);
+      if (!lc) continue;
+
+      if (lc.sources) {
+        for (let i = 0; i < lc.sources.length; i++) {
+          const src = lc.sources[i];
+          const ref = src.origin?.toString() ?? '';
+          if (ref) {
+            refs.push(new Reference('standard', ref, src.type, `localizations.${lang}.sources[${i}]`));
+          }
+        }
+      }
+
+      const texts = [
+        ...(lc.definitions?.map(d => d.content ?? '') ?? []),
+        ...(lc.notes?.map(n => typeof n === 'object' ? (n.content ?? '') : String(n)) ?? []),
+      ];
+      for (const text of texts) {
+        refs.push(..._extractEmbedded(text));
+      }
+    }
+
+    return refs;
+  }
+
+  resolveReference(ref, collection) {
+    if (ref.type !== 'concept') return null;
+    return collection.byId(ref.target);
+  }
+
+  resolveAll(concept, collection) {
+    const resolved = new Map();
+    for (const ref of this.extractReferences(concept)) {
+      if (ref.type === 'concept') {
+        resolved.set(ref.target, this.resolveReference(ref, collection));
+      }
+    }
+    return resolved;
+  }
+}
+
+const CONCEPT_REF_RE = /\{\{([^}]+)\}\}|\b(\d+(?:\.\d+)+)\b/g;
+
+function _extractEmbedded(text) {
+  const refs = [];
+  let m;
+  CONCEPT_REF_RE.lastIndex = 0;
+  while ((m = CONCEPT_REF_RE.exec(text)) !== null) {
+    const target = m[1] ?? m[2];
+    if (target && /^\d+(\.\d+)+$/.test(target)) {
+      refs.push(new Reference('concept', target, 'embedded', null));
+    }
+  }
+  return refs;
+}
+
+export const referenceResolver = new ReferenceResolver();