glossarist 0.4.15 → 0.4.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glossarist",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "description": "JavaScript SDK for Glossarist GCR packages — read, write, validate, and manage terminology concepts",
   "type": "module",
   "main": "src/index.js",
@@ -37,6 +37,11 @@
       "import": "./src/validators/index.js",
       "default": "./src/validators/index.js"
     },
+    "./diff": {
+      "types": "./src/diff/index.d.ts",
+      "import": "./src/diff/index.js",
+      "default": "./src/diff/index.js"
+    },
     "./rdf": {
       "types": "./src/rdf/index.d.ts",
       "import": "./src/rdf/index.js",

package/src/concept-diff.js

@@ -0,0 +1,19 @@
+export {
+  diffConcepts,
+  diffLocalizedConcepts,
+  diffText,
+  diffList,
+  diffSet,
+  ConceptDiff,
+  ConceptLevelDiff,
+  LocalizedConceptDiff,
+  MetadataDiff,
+  DiffStats,
+  ListDiff,
+  TextDiff,
+  TextHunk,
+  Change,
+  Added,
+  Removed,
+  Changed,
+} from './diff/index.js';

package/src/diff/change.js

@@ -0,0 +1,111 @@
+import { GlossaristModel } from '../models/base.js';
+import { TextDiff } from './text-diff.js';
+
+export const CHANGE_ADDED = 'added';
+export const CHANGE_REMOVED = 'removed';
+export const CHANGE_CHANGED = 'changed';
+
+function serializeValue(v) {
+  if (v == null) return null;
+  if (v instanceof GlossaristModel) return v.toJSON();
+  if (Array.isArray(v)) return v.map(serializeValue);
+  if (typeof v === 'object') {
+    const out = {};
+    for (const [k, val] of Object.entries(v)) out[k] = serializeValue(val);
+    return out;
+  }
+  return v;
+}
+
+export class Change extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.path = data.path ?? null;
+  }
+
+  get type() {
+    throw new Error(`${this.constructor.name} must override type getter`);
+  }
+
+  static fromJSON(data) {
+    return deserializeChange(data);
+  }
+}
+
+export class Added extends Change {
+  constructor(data = {}) {
+    super(data);
+    this.value = data.value ?? null;
+  }
+
+  get type() { return CHANGE_ADDED; }
+
+  toJSON() {
+    const obj = { type: CHANGE_ADDED };
+    if (this.path != null) obj.path = this.path;
+    obj.value = serializeValue(this.value);
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new Added(data);
+  }
+}
+
+export class Removed extends Change {
+  constructor(data = {}) {
+    super(data);
+    this.value = data.value ?? null;
+  }
+
+  get type() { return CHANGE_REMOVED; }
+
+  toJSON() {
+    const obj = { type: CHANGE_REMOVED };
+    if (this.path != null) obj.path = this.path;
+    obj.value = serializeValue(this.value);
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new Removed(data);
+  }
+}
+
+export class Changed extends Change {
+  constructor(data = {}) {
+    super(data);
+    this.oldValue = data.oldValue ?? data.old_value ?? null;
+    this.newValue = data.newValue ?? data.new_value ?? null;
+    this._textDiff = data.textDiff ?? (data.text_diff ? TextDiff.fromJSON(data.text_diff) : null);
+  }
+
+  get type() { return CHANGE_CHANGED; }
+
+  get textDiff() {
+    return this._textDiff;
+  }
+
+  toJSON() {
+    const obj = { type: CHANGE_CHANGED };
+    if (this.path != null) obj.path = this.path;
+    obj.old_value = serializeValue(this.oldValue);
+    obj.new_value = serializeValue(this.newValue);
+    if (this._textDiff) obj.text_diff = this._textDiff.toJSON();
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new Changed(data);
+  }
+}
+
+export function deserializeChange(data) {
+  switch (data?.type) {
+    case CHANGE_ADDED: return Added.fromJSON(data);
+    case CHANGE_REMOVED: return Removed.fromJSON(data);
+    case CHANGE_CHANGED: return Changed.fromJSON(data);
+    default:
+      throw new Error(`Unknown change type: ${data?.type}`);
+  }
+}

package/src/diff/collection-diff.js

@@ -0,0 +1,164 @@
+import { GlossaristModel } from '../models/base.js';
+import { Added, Removed } from './change.js';
+import { ConceptDiff, DiffStats, diffConcepts } from './concept-diff.js';
+
+export class ConceptCollectionDiff extends GlossaristModel {
+  constructor(data = {}) {
+    super();
+    this.oldCount = data.oldCount ?? data.old_count ?? 0;
+    this.newCount = data.newCount ?? data.new_count ?? 0;
+
+    this._matched = wrapIdList(data.matched);
+    this._added = wrapIdList(data.added);
+    this._removed = wrapIdList(data.removed);
+
+    this._conceptDiffs = {};
+    const raw = data.conceptDiffs ?? data.concept_diffs ?? {};
+    for (const [id, diff] of Object.entries(raw)) {
+      this._conceptDiffs[id] = diff instanceof ConceptDiff
+        ? diff
+        : ConceptDiff.fromJSON(diff);
+    }
+  }
+
+  get matched() { return this._matched; }
+  get added() { return this._added; }
+  get removed() { return this._removed; }
+  get conceptDiffs() { return this._conceptDiffs; }
+
+  get changedIds() {
+    return Object.keys(this._conceptDiffs);
+  }
+
+  get hasChanges() {
+    return this._added.length > 0
+      || this._removed.length > 0
+      || Object.values(this._conceptDiffs).some(d => d.hasChanges);
+  }
+
+  conceptDiff(id) {
+    return this._conceptDiffs[id] ?? null;
+  }
+
+  get stats() {
+    let added = this._added.length;
+    let removed = this._removed.length;
+    let changed = 0;
+    for (const diff of Object.values(this._conceptDiffs)) {
+      const s = diff.stats;
+      added += s.added;
+      removed += s.removed;
+      changed += s.changed;
+    }
+    return new DiffStats({ added, removed, changed });
+  }
+
+  get similarity() {
+    if (this._matched.length === 0) return 0;
+    let sum = 0;
+    let n = 0;
+    for (const entry of this._matched) {
+      const id = entry.value;
+      const diff = this._conceptDiffs[id];
+      sum += diff ? diff.similarity : 1.0;
+      n++;
+    }
+    return n > 0 ? Math.round((sum / n) * 10000) / 10000 : 1.0;
+  }
+
+  *walk() {
+    for (let i = 0; i < this._added.length; i++) {
+      yield { path: `added[${i}]`, change: this._added[i] };
+    }
+    for (let i = 0; i < this._removed.length; i++) {
+      yield { path: `removed[${i}]`, change: this._removed[i] };
+    }
+    for (const [id, diff] of Object.entries(this._conceptDiffs)) {
+      for (const entry of diff.walk()) {
+        yield { path: `concepts.${id}.${entry.path}`, change: entry.change, conceptId: id, language: entry.language };
+      }
+    }
+  }
+
+  toJSON() {
+    const obj = {
+      old_count: this.oldCount,
+      new_count: this.newCount,
+      matched: this._matched.map(c => c.toJSON()),
+      added: this._added.map(c => c.toJSON()),
+      removed: this._removed.map(c => c.toJSON()),
+      concept_diffs: {},
+    };
+    for (const [id, diff] of Object.entries(this._conceptDiffs)) {
+      obj.concept_diffs[id] = diff.toJSON();
+    }
+    return obj;
+  }
+
+  static fromJSON(data) {
+    return new ConceptCollectionDiff(data);
+  }
+}
+
+export function diffConceptCollections(oldCollection, newCollection, options = {}) {
+  const language = options.language ?? 'eng';
+
+  const oldConcepts = extractConcepts(oldCollection);
+  const newConcepts = extractConcepts(newCollection);
+
+  const oldMap = new Map(oldConcepts.map(c => [c.id, c]));
+  const newMap = new Map(newConcepts.map(c => [c.id, c]));
+
+  const oldIds = new Set(oldMap.keys());
+  const newIds = new Set(newMap.keys());
+
+  const matchedIds = [...newIds].filter(id => oldIds.has(id)).sort();
+  const addedIds = [...newIds].filter(id => !oldIds.has(id)).sort();
+  const removedIds = [...oldIds].filter(id => !newIds.has(id)).sort();
+
+  const conceptDiffs = {};
+  for (const id of matchedIds) {
+    const oldConcept = oldMap.get(id);
+    const newConcept = newMap.get(id);
+
+    if (options.skipUnchanged && conceptsEqual(oldConcept, newConcept)) {
+      continue;
+    }
+
+    const diff = diffConcepts(oldConcept, newConcept, language);
+    if (diff.hasChanges || !options.skipUnchanged) {
+      conceptDiffs[id] = diff;
+    }
+  }
+
+  return new ConceptCollectionDiff({
+    oldCount: oldConcepts.length,
+    newCount: newConcepts.length,
+    matched: matchedIds.map(id => new Added({ value: id })),
+    added: addedIds.map(id => new Added({ value: id })),
+    removed: removedIds.map(id => new Removed({ value: id })),
+    conceptDiffs,
+  });
+}
+
+function extractConcepts(collection) {
+  if (collection == null) return [];
+  if (Array.isArray(collection)) return collection;
+  if (typeof collection.toArray === 'function') return collection.toArray();
+  if (Symbol.iterator in Object(collection)) return [...collection];
+  return [];
+}
+
+function conceptsEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (typeof a.equals === 'function' && typeof b.equals === 'function') {
+    return a.equals(b);
+  }
+  return JSON.stringify(a?.toJSON?.()) === JSON.stringify(b?.toJSON?.());
+}
+
+function wrapIdList(data) {
+  if (!data) return [];
+  return data.map(c => c instanceof Added || c instanceof Removed ? c : Added.fromJSON(c));
+}