glossarist 0.4.34 → 0.4.35

package/package.json

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

package/src/models/concept-system-type.js

@@ -0,0 +1,26 @@
+// ConceptSystemType — ISO 12620 A.7.1 concept system type enum.
+//
+// Permissible instances per ISO 12620:
+//   generic     — species are part of the extension of the genus
+//   partitive   — based on whole-part relations
+//   sequential  — based on spatial and temporal relations
+//   associative — based on thematic or pragmatic relations
+//   mixed       — two or more of the above (the realistic case)
+
+export const CONCEPT_SYSTEM_TYPE = Object.freeze({
+  GENERIC: 'generic',
+  PARTITIVE: 'partitive',
+  SEQUENTIAL: 'sequential',
+  ASSOCIATIVE: 'associative',
+  MIXED: 'mixed',
+});
+
+export const CONCEPT_SYSTEM_TYPE_VALUES = Object.freeze(
+  Object.values(CONCEPT_SYSTEM_TYPE),
+);
+
+export function isValidConceptSystemType(value) {
+  return CONCEPT_SYSTEM_TYPE_VALUES.includes(value);
+}
+
+export default CONCEPT_SYSTEM_TYPE;

package/src/models/concept-system.js

@@ -0,0 +1,117 @@
+// ConceptSystem — first-class concept system entity per ISO 12620 A.7.
+//
+// Promotes the previously-implicit concept system (domains + tags +
+// relation graph) to an explicit first-class entity. Per-file at
+// `concept-systems/<id>.yaml`.
+//
+// See docs/design/concept-systems.md (concept-model repo).
+
+import { GlossaristModel } from './base.js';
+import { ConceptRef } from './concept-ref.js';
+import {
+  CONCEPT_SYSTEM_TYPE,
+  CONCEPT_SYSTEM_TYPE_VALUES,
+  isValidConceptSystemType,
+} from './concept-system-type.js';
+
+export class ConceptSystem extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.id = _ensureNonEmptyString(data.id, 'id');
+    this.name = _ensureName(data.name);
+    this.type = _resolveType(data.type);
+    this.domain = data.domain ?? null;
+    this.purpose = data.purpose ?? null;
+    this.members = _ensureMembers(data.members);
+    this.hyperedges = Array.isArray(data.hyperedges) ? [...data.hyperedges] : [];
+    this.rootConcepts = Array.isArray(data.rootConcepts)
+      ? data.rootConcepts.map(c => c instanceof ConceptRef ? c : new ConceptRef(c))
+      : [];
+    this.sources = Array.isArray(data.sources) ? [...data.sources] : [];
+    this.status = data.status ?? null;
+  }
+
+  get isGeneric()     { return this.type === CONCEPT_SYSTEM_TYPE.GENERIC; }
+  get isPartitive()   { return this.type === CONCEPT_SYSTEM_TYPE.PARTITIVE; }
+  get isSequential()  { return this.type === CONCEPT_SYSTEM_TYPE.SEQUENTIAL; }
+  get isAssociative() { return this.type === CONCEPT_SYSTEM_TYPE.ASSOCIATIVE; }
+  get isMixed()       { return this.type === CONCEPT_SYSTEM_TYPE.MIXED; }
+
+  hasHyperedge(edgeId) {
+    return this.hyperedges.includes(edgeId);
+  }
+
+  hasMember(refOrUri) {
+    const uri = typeof refOrUri === 'string' ? refOrUri : _refUri(refOrUri);
+    return this.members.some(m => _refUri(m) === uri);
+  }
+
+  identity() {
+    return this.id;
+  }
+
+  toJSON() {
+    const obj = {
+      id: this.id,
+      name: { ...this.name },
+      type: this.type,
+      members: this.members.map(m => m.toJSON()),
+    };
+    if (this.domain != null) obj.domain = this.domain;
+    if (this.purpose != null) obj.purpose = { ...this.purpose };
+    if (this.hyperedges.length > 0) obj.hyperedges = [...this.hyperedges];
+    if (this.rootConcepts.length > 0) obj.rootConcepts = this.rootConcepts.map(c => c.toJSON());
+    if (this.sources.length > 0) obj.sources = [...this.sources];
+    if (this.status != null) obj.status = this.status;
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new ConceptSystem(data);
+  }
+}
+
+function _ensureNonEmptyString(value, fieldName) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`ConceptSystem#${fieldName} must be a non-empty string`);
+  }
+  return value;
+}
+
+function _ensureName(value) {
+  if (value == null) return {};
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('ConceptSystem#name must be a localized object (e.g. { eng: "..." })');
+  }
+  return { ...value };
+}
+
+function _resolveType(value) {
+  if (value == null) {
+    throw new Error(
+      'ConceptSystem#type is required; one of ' +
+      CONCEPT_SYSTEM_TYPE_VALUES.join(', '),
+    );
+  }
+  if (!isValidConceptSystemType(value)) {
+    throw new Error(
+      `ConceptSystem#type ${JSON.stringify(value)} invalid; ` +
+      `must be one of: ${CONCEPT_SYSTEM_TYPE_VALUES.join(', ')}`,
+    );
+  }
+  return value;
+}
+
+function _ensureMembers(values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    throw new Error('ConceptSystem#members must be a non-empty array');
+  }
+  return values.map(v => v instanceof ConceptRef ? v : new ConceptRef(v));
+}
+
+function _refUri(ref) {
+  const r = ref?.ref ?? ref ?? {};
+  return `${r.source ?? ''}:${r.id ?? ''}`;
+}
+
+export default ConceptSystem;

package/src/models/concept-type.js

@@ -0,0 +1,25 @@
+// ConceptType — ISO 704:2022 §5.2-5.3 general vs individual concept.
+//
+//   general    — concept corresponds to a category of objects
+//                (designated by terms or symbols)
+//   individual — concept corresponds to a unique object
+//                (designated by proper names / appellations)
+//
+// Individual concepts occupy the bottom rung of a concept ladder
+// and cannot be subdivided into more specific concepts, but CAN be
+// subdivided into parts via a partitive relation.
+
+export const CONCEPT_TYPE = Object.freeze({
+  GENERAL: 'general',
+  INDIVIDUAL: 'individual',
+});
+
+export const CONCEPT_TYPE_VALUES = Object.freeze(Object.values(CONCEPT_TYPE));
+
+export const DEFAULT_CONCEPT_TYPE = CONCEPT_TYPE.GENERAL;
+
+export function isValidConceptType(value) {
+  return CONCEPT_TYPE_VALUES.includes(value);
+}
+
+export default CONCEPT_TYPE;

package/src/models/equivalence-degree.js

@@ -0,0 +1,25 @@
+// EquivalenceDegree — ISO 704:2022 §7.7.3 cross-language equivalence.
+//
+//   full        — equivalent intension across languages (default)
+//   partial     — overlapping but not identical intension
+//   none        — no corresponding concept in this language
+//   directional — monodirectional equivalence (see equivalence_note)
+
+export const EQUIVALENCE_DEGREE = Object.freeze({
+  FULL: 'full',
+  PARTIAL: 'partial',
+  NONE: 'none',
+  DIRECTIONAL: 'directional',
+});
+
+export const EQUIVALENCE_DEGREE_VALUES = Object.freeze(
+  Object.values(EQUIVALENCE_DEGREE),
+);
+
+export const DEFAULT_EQUIVALENCE_DEGREE = EQUIVALENCE_DEGREE.FULL;
+
+export function isValidEquivalenceDegree(value) {
+  return EQUIVALENCE_DEGREE_VALUES.includes(value);
+}
+
+export default EQUIVALENCE_DEGREE;

package/src/models/sequential-hyperedge.js

@@ -0,0 +1,56 @@
+// SequentialHyperedge — an ISO 12620 A.6.3 / ISO 704:2022 §5.5.5
+// sequential relation connecting a comprehensive concept to two or
+// more subordinate concepts in an ORDERED sequence (temporal,
+// spatial, causal, developmental).
+//
+// Mirror of PartitiveHyperedge and GenericHyperedge. Member array
+// order IS significant — reversing the array reverses the sequence.
+// Use cases: manufacturing process steps, biological life cycles,
+// software release lifecycles, supply chain stages, geological eras.
+//
+// See docs/design/abstract-nary-relation.md (concept-model repo).
+
+import { AbstractHyperedge } from './abstract-hyperedge.js';
+import { SequentialMember } from './sequential-member.js';
+import { HyperedgeRegistry } from './hyperedge-registry.js';
+
+export class SequentialHyperedge extends AbstractHyperedge {
+  // Per-class metadata block — the OCP contract.
+  static wireKey     = 'sequential_relations';
+  static typeTag     = 'sequential_relation';
+  static rdfType     = 'gloss:SequentialRelation';
+  static memberClass = SequentialMember;
+  static v1WireKeys  = [];
+  static kindLabel   = 'SEQ';
+
+  constructor(data = {}) {
+    super(data);
+    this.members = data?.members == null
+      ? this.members
+      : (Array.isArray(data.members)
+          ? data.members.map(m =>
+              m instanceof SequentialMember ? m : new SequentialMember(m))
+          : this.members);
+  }
+
+  static identityOf(value) {
+    const v = value ?? {};
+    const c = v.comprehensive ?? {};
+    // For sequential, member order IS significant — do NOT sort.
+    const memberKeys = Array.isArray(v.members)
+      ? v.members.map(m => {
+          const r = m?.ref ?? m ?? {};
+          return `${r.source ?? ''}:${r.id ?? ''}`;
+        })
+      : [];
+    return `${c.source ?? ''}:${c.id ?? ''}|${memberKeys.join('|')}`;
+  }
+
+  static fromJSON(data) {
+    return new SequentialHyperedge(data);
+  }
+}
+
+export default SequentialHyperedge;
+
+HyperedgeRegistry.register(SequentialHyperedge);

package/src/models/sequential-member.js

@@ -0,0 +1,13 @@
+// SequentialMember — one member of a SequentialHyperedge. Inherits
+// the MECE shape from HyperedgeMember. Distinct leaf class for type
+// safety. Member array order IS significant for sequential hyperedges.
+//
+// See docs/design/abstract-nary-relation.md (concept-model repo).
+
+import { HyperedgeMember } from './hyperedge-member.js';
+
+export class SequentialMember extends HyperedgeMember {
+  // Inherits all attributes and validations from HyperedgeMember.
+}
+
+export default SequentialMember;