glossarist 0.4.14 → 0.4.16

package/src/diff/diff-patch.js

@@ -0,0 +1,234 @@
+import { Concept } from '../models/concept.js';
+import { Added, Removed, Changed } from './change.js';
+import { ListDiff } from './list-diff.js';
+import { TextDiff, TextHunk } from './text-diff.js';
+import {
+  ConceptDiff,
+  ConceptLevelDiff,
+  LocalizedConceptDiff,
+  MetadataDiff,
+} from './concept-diff.js';
+
+const CONCEPT_METADATA_JSON_KEYS = {
+  status: 'status',
+  term: 'term',
+  uri: 'uri',
+  schemaVersion: 'schema_version',
+};
+
+const LOC_METADATA_JSON_KEYS = {
+  entryStatus: 'entry_status',
+  classification: 'classification',
+  reviewType: 'review_type',
+  domain: 'domain',
+  release: 'release',
+  lineageSourceSimilarity: 'lineage_source_similarity',
+  script: 'script',
+  system: 'system',
+  reviewDate: 'review_date',
+  reviewDecisionDate: 'review_decision_date',
+  reviewDecisionEvent: 'review_decision_event',
+  reviewStatus: 'review_status',
+  reviewDecision: 'review_decision',
+  reviewDecisionNotes: 'review_decision_notes',
+};
+
+export function applyDiff(oldConcept, diff) {
+  const json = oldConcept.toJSON();
+
+  applyConceptLevelPatch(json, diff.concept);
+  applyLanguagePatch(json, diff);
+
+  for (const [lang, lcDiff] of Object.entries(diff.localizations)) {
+    applyLocalizedPatch(json, lang, lcDiff);
+  }
+
+  return Concept.fromJSON(json);
+}
+
+export function reverseDiff(diff) {
+  const concept = new ConceptLevelDiff({
+    sources: reverseListDiff(diff.concept.sources),
+    dates: reverseListDiff(diff.concept.dates),
+    relatedConcepts: reverseListDiff(diff.concept.relatedConcepts),
+    groups: reverseListDiff(diff.concept.groups),
+    sections: reverseListDiff(diff.concept.sections),
+    tags: reverseListDiff(diff.concept.tags),
+    metadata: reverseMetadataDiff(diff.concept.metadata),
+  });
+
+  const languages = reverseListDiff(diff.languages);
+
+  const localizations = {};
+  for (const [lang, lcDiff] of Object.entries(diff.localizations)) {
+    localizations[lang] = new LocalizedConceptDiff({
+      languageCode: lcDiff.languageCode,
+      designations: reverseListDiff(lcDiff.designations),
+      definitions: reverseListDiff(lcDiff.definitions),
+      notes: reverseListDiff(lcDiff.notes),
+      examples: reverseListDiff(lcDiff.examples),
+      sources: reverseListDiff(lcDiff.sources),
+      dates: reverseListDiff(lcDiff.dates),
+      related: reverseListDiff(lcDiff.related),
+      metadata: reverseMetadataDiff(lcDiff.metadata),
+      totalItems: lcDiff._totalItems,
+    });
+  }
+
+  return new ConceptDiff({
+    oldId: diff.newId,
+    newId: diff.oldId,
+    concept,
+    languages,
+    localizations,
+    totalItems: diff._totalItems,
+  });
+}
+
+function applyConceptLevelPatch(json, conceptDiff) {
+  json.sources = applyListPatch(json.sources ?? [], conceptDiff.sources, sourceIdentity);
+  json.dates = applyListPatch(json.dates ?? [], conceptDiff.dates, dateIdentity);
+  json.related = applyListPatch(json.related ?? [], conceptDiff.relatedConcepts, relatedIdentity);
+
+  json.tags = applyListPatch(json.tags ?? [], conceptDiff.tags, s => String(s));
+
+  applyMetadataPatch(json, conceptDiff.metadata, CONCEPT_METADATA_JSON_KEYS);
+}
+
+function applyLanguagePatch(json, conceptDiff) {
+  if (!json.localizations) json.localizations = {};
+  for (const entry of conceptDiff.languages.added) {
+    if (!(entry.value in json.localizations)) {
+      json.localizations[entry.value] = {};
+    }
+  }
+  for (const entry of conceptDiff.languages.removed) {
+    delete json.localizations[entry.value];
+  }
+}
+
+function applyLocalizedPatch(json, lang, lcDiff) {
+  if (!json.localizations) json.localizations = {};
+  if (!(lang in json.localizations)) {
+    json.localizations[lang] = {};
+  }
+  const loc = json.localizations[lang];
+
+  loc.terms = applyListPatch(loc.terms ?? [], lcDiff.designations, designationIdentity);
+  loc.definition = applyListPatch(loc.definition ?? [], lcDiff.definitions, definitionIdentity);
+  loc.notes = applyListPatch(loc.notes ?? [], lcDiff.notes, definitionIdentity);
+  loc.examples = applyListPatch(loc.examples ?? [], lcDiff.examples, definitionIdentity);
+  loc.sources = applyListPatch(loc.sources ?? [], lcDiff.sources, sourceIdentity);
+  loc.dates = applyListPatch(loc.dates ?? [], lcDiff.dates, dateIdentity);
+  loc.related = applyListPatch(loc.related ?? [], lcDiff.related, relatedIdentity);
+
+  applyMetadataPatch(loc, lcDiff.metadata, LOC_METADATA_JSON_KEYS);
+}
+
+function applyListPatch(existingItems, listDiff, identityFn) {
+  let result = [...existingItems];
+
+  for (const entry of listDiff.added) {
+    result.push(toJsonValue(entry.value));
+  }
+
+  for (const entry of listDiff.removed) {
+    const targetKey = identityFn(entry.value);
+    result = result.filter(item => identityFn(item) !== targetKey);
+  }
+
+  for (const entry of listDiff.changed) {
+    const oldKey = identityFn(entry.oldValue);
+    result = result.map(item =>
+      identityFn(item) === oldKey ? toJsonValue(entry.newValue) : item,
+    );
+  }
+
+  return result;
+}
+
+function applyMetadataPatch(target, metadataDiff, keyMap) {
+  for (const [field, change] of Object.entries(metadataDiff.changes)) {
+    const jsonKey = keyMap[field];
+    if (!jsonKey) continue;
+    if (change.newValue == null) {
+      delete target[jsonKey];
+    } else {
+      target[jsonKey] = change.newValue;
+    }
+  }
+}
+
+function reverseListDiff(listDiff) {
+  const added = listDiff.removed.map(r => new Added({ value: r.value, path: r.path }));
+  const removed = listDiff.added.map(a => new Removed({ value: a.value, path: a.path }));
+  const changed = listDiff.changed.map(c => new Changed({
+    oldValue: c.newValue,
+    newValue: c.oldValue,
+    textDiff: c.textDiff ? reverseTextDiff(c.textDiff) : null,
+    path: c.path,
+  }));
+  return new ListDiff({ added, removed, changed });
+}
+
+function reverseMetadataDiff(metadataDiff) {
+  const changes = {};
+  for (const [field, change] of Object.entries(metadataDiff.changes)) {
+    changes[field] = new Changed({
+      oldValue: change.newValue,
+      newValue: change.oldValue,
+    });
+  }
+  return new MetadataDiff({ changes });
+}
+
+function reverseTextDiff(textDiff) {
+  const hunks = textDiff.hunks.map(h => {
+    if (h.type === 'added') return new TextHunk({ type: 'removed', text: h.text });
+    if (h.type === 'removed') return new TextHunk({ type: 'added', text: h.text });
+    return new TextHunk({ type: 'equal', text: h.text });
+  });
+  return new TextDiff({
+    oldText: textDiff.newText,
+    newText: textDiff.oldText,
+    hunks,
+  });
+}
+
+function toJsonValue(value) {
+  if (value == null) return null;
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value.toJSON === 'function') return value.toJSON();
+  return value;
+}
+
+function designationIdentity(d) {
+  const data = typeof d?.toJSON === 'function' ? d.toJSON() : d ?? {};
+  const type = data.type ?? 'expression';
+  const text = String(data.designation ?? '').toLowerCase().trim();
+  return `${type}|${text}`;
+}
+
+function definitionIdentity(d) {
+  const data = typeof d?.toJSON === 'function' ? d.toJSON() : d ?? {};
+  return JSON.stringify(data);
+}
+
+function sourceIdentity(s) {
+  const data = typeof s?.toJSON === 'function' ? s.toJSON() : s ?? {};
+  const ref = data.origin?.ref;
+  return `${data.type ?? ''}|${ref?.source ?? ''}|${ref?.id ?? ''}`;
+}
+
+function dateIdentity(d) {
+  const data = typeof d?.toJSON === 'function' ? d.toJSON() : d ?? {};
+  return data.type ?? '';
+}
+
+function relatedIdentity(r) {
+  const data = typeof r?.toJSON === 'function' ? r.toJSON() : r ?? {};
+  const ref = data.ref;
+  return `${data.type ?? ''}|${ref?.source ?? ''}|${ref?.id ?? ''}`;
+}

package/src/diff/diff-renderer.js

@@ -0,0 +1,220 @@
+import { TextDiff } from './text-diff.js';
+
+const COLORS = {
+  red: s => `\x1b[31m${s}\x1b[0m`,
+  green: s => `\x1b[32m${s}\x1b[0m`,
+  yellow: s => `\x1b[33m${s}\x1b[0m`,
+  cyan: s => `\x1b[36m${s}\x1b[0m`,
+  dim: s => `\x1b[2m${s}\x1b[0m`,
+  bold: s => `\x1b[1m${s}\x1b[0m`,
+};
+
+export function renderConceptDiff(diff, options = {}) {
+  const colors = options.colors ?? false;
+  const showUnchanged = options.showUnchanged ?? false;
+  const lines = [];
+
+  const pct = Math.round(diff.similarity * 100);
+  const idPart = diff.oldId && diff.newId && diff.oldId !== diff.newId
+    ? `${diff.oldId} → ${diff.newId}`
+    : (diff.newId ?? diff.oldId ?? '?');
+
+  const similarityStr = colors ? colorizeSimilarity(pct) : `${pct}%`;
+  lines.push(`Concept "${idPart}" — ${similarityStr} similar`);
+
+  if (!diff.hasChanges && !showUnchanged) {
+    lines.push('  (no changes)');
+    return lines.join('\n');
+  }
+
+  if (diff.concept.hasChanges || showUnchanged) {
+    lines.push('');
+    lines.push('Concept-level:');
+    lines.push(renderConceptLevel(diff.concept, colors));
+  }
+
+  if (diff.languages.hasChanges || showUnchanged) {
+    lines.push('');
+    lines.push('Languages:');
+    lines.push(renderLanguageSet(diff.languages, colors));
+  }
+
+  for (const lang of diff.localizationLanguages) {
+    const lcDiff = diff.localization(lang);
+    if (!lcDiff) continue;
+    if (lcDiff.hasChanges || showUnchanged) {
+      lines.push('');
+      lines.push(`Localization (${lang}):`);
+      lines.push(renderLocalized(lcDiff, colors));
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export function renderCollectionDiff(diff, options = {}) {
+  const colors = options.colors ?? false;
+  const lines = [];
+
+  const pct = Math.round(diff.similarity * 100);
+  const similarityStr = colors ? colorizeSimilarity(pct) : `${pct}%`;
+
+  lines.push(`Collection comparison — ${similarityStr} similar overall`);
+  lines.push(`  Old: ${diff.oldCount} concepts`);
+  lines.push(`  New: ${diff.newCount} concepts`);
+  lines.push(`  Matched: ${diff.matched.length}`);
+  lines.push(`  Added: ${diff.added.length}`);
+  lines.push(`  Removed: ${diff.removed.length}`);
+
+  if (diff.added.length > 0) {
+    lines.push('');
+    lines.push(colors ? COLORS.green('Added concepts:') : 'Added concepts:');
+    for (const entry of diff.added) {
+      lines.push(`  + ${entry.value}`);
+    }
+  }
+
+  if (diff.removed.length > 0) {
+    lines.push('');
+    lines.push(colors ? COLORS.red('Removed concepts:') : 'Removed concepts:');
+    for (const entry of diff.removed) {
+      lines.push(`  - ${entry.value}`);
+    }
+  }
+
+  const changedDiffs = Object.entries(diff.conceptDiffs)
+    .filter(([, d]) => d.hasChanges)
+    .sort(([, a], [, b]) => a.similarity - b.similarity);
+
+  if (changedDiffs.length > 0) {
+    lines.push('');
+    lines.push('Changed concepts:');
+    for (const [id, conceptDiff] of changedDiffs) {
+      const conceptPct = Math.round(conceptDiff.similarity * 100);
+      const pctStr = colors ? colorizeSimilarity(conceptPct) : `${conceptPct}%`;
+      lines.push(`  ${id}: ${pctStr}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export function renderTextDiff(textDiff, options = {}) {
+  if (!(textDiff instanceof TextDiff)) {
+    textDiff = TextDiff.fromJSON(textDiff);
+  }
+  const colors = options.colors ?? false;
+  const lines = [];
+
+  for (const hunk of textDiff.hunks) {
+    if (hunk.type === 'equal') {
+      lines.push(`  ${hunk.text}`);
+    } else if (hunk.type === 'added') {
+      lines.push(colors ? `+ ${COLORS.green(hunk.text)}` : `+ ${hunk.text}`);
+    } else if (hunk.type === 'removed') {
+      lines.push(colors ? `- ${COLORS.red(hunk.text)}` : `- ${hunk.text}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function renderConceptLevel(diff, colors) {
+  const lines = [];
+  lines.push(...renderListDiff('Sources', diff.sources, colors, itemLabel));
+  lines.push(...renderListDiff('Dates', diff.dates, colors, itemLabel));
+  lines.push(...renderListDiff('Related', diff.relatedConcepts, colors, itemLabel));
+  lines.push(...renderListDiff('Groups', diff.groups, colors, itemLabel));
+  lines.push(...renderListDiff('Sections', diff.sections, colors, itemLabel));
+  lines.push(...renderListDiff('Tags', diff.tags, colors, itemLabel));
+  lines.push(...renderMetadataDiff(diff.metadata));
+  return lines.filter(Boolean).join('\n');
+}
+
+function renderLanguageSet(diff, colors) {
+  const lines = [];
+  for (const entry of diff.added) {
+    lines.push(colors ? `  + ${COLORS.green(entry.value)}` : `  + ${entry.value}`);
+  }
+  for (const entry of diff.removed) {
+    lines.push(colors ? `  - ${COLORS.red(entry.value)}` : `  - ${entry.value}`);
+  }
+  return lines.join('\n');
+}
+
+function renderLocalized(diff, colors) {
+  const lines = [];
+  lines.push(...renderListDiff('Designations', diff.designations, colors, designationLabel));
+  lines.push(...renderListDiff('Definitions', diff.definitions, colors, definitionLabel));
+  lines.push(...renderListDiff('Notes', diff.notes, colors, definitionLabel));
+  lines.push(...renderListDiff('Examples', diff.examples, colors, definitionLabel));
+  lines.push(...renderListDiff('Sources', diff.sources, colors, itemLabel));
+  lines.push(...renderListDiff('Dates', diff.dates, colors, itemLabel));
+  lines.push(...renderListDiff('Related', diff.related, colors, itemLabel));
+  lines.push(...renderMetadataDiff(diff.metadata));
+  return lines.filter(Boolean).join('\n');
+}
+
+function renderListDiff(label, listDiff, colors, labelFn) {
+  if (!listDiff.hasChanges) return [];
+  const lines = [`  ${label}:`];
+  for (const entry of listDiff.added) {
+    const text = `    + ${labelFn(entry.value)}`;
+    lines.push(colors ? COLORS.green(text) : text);
+  }
+  for (const entry of listDiff.removed) {
+    const text = `    - ${labelFn(entry.value)}`;
+    lines.push(colors ? COLORS.red(text) : text);
+  }
+  for (const entry of listDiff.changed) {
+    const oldLabel = labelFn(entry.oldValue);
+    const newLabel = labelFn(entry.newValue);
+    lines.push(`    ~ ${oldLabel} → ${newLabel}`);
+  }
+  return lines;
+}
+
+function renderMetadataDiff(metadataDiff) {
+  if (!metadataDiff.hasChanges) return [];
+  const lines = [`  Metadata:`];
+  for (const [field, change] of Object.entries(metadataDiff.changes)) {
+    const oldVal = formatScalar(change.oldValue);
+    const newVal = formatScalar(change.newValue);
+    lines.push(`    ~ ${field}: ${oldVal} → ${newVal}`);
+  }
+  return lines;
+}
+
+function designationLabel(d) {
+  if (!d) return '?';
+  const text = d.designation ?? '?';
+  const status = d.normativeStatus ? ` (${d.normativeStatus})` : '';
+  return `${text}${status}`;
+}
+
+function definitionLabel(d) {
+  if (!d) return '?';
+  return d.content ?? '?';
+}
+
+function itemLabel(item) {
+  if (item == null) return '?';
+  if (typeof item === 'string') return item;
+  if (typeof item === 'number') return String(item);
+  if (typeof item.toJSON === 'function') {
+    return JSON.stringify(item.toJSON());
+  }
+  return String(item);
+}
+
+function formatScalar(val) {
+  if (val == null) return '∅';
+  if (typeof val === 'string') return val;
+  return String(val);
+}
+
+function colorizeSimilarity(pct) {
+  if (pct >= 95) return COLORS.green(`${pct}%`);
+  if (pct >= 80) return COLORS.yellow(`${pct}%`);
+  return COLORS.red(`${pct}%`);
+}

package/src/diff/index.d.ts

@@ -0,0 +1,179 @@
+import type { GlossaristModel } from '../models/base';
+
+// ── Text diff ──────────────────────────────────────────────────────────
+
+export type HunkType = 'equal' | 'added' | 'removed';
+
+export class TextHunk extends GlossaristModel {
+  readonly type: HunkType;
+  readonly text: string;
+  toJSON(): { type: HunkType; text: string };
+  static fromJSON(data: { type: HunkType; text: string }): TextHunk;
+}
+
+export class TextDiff extends GlossaristModel {
+  readonly oldText: string;
+  readonly newText: string;
+  readonly hunks: TextHunk[];
+  readonly hasChanges: boolean;
+  readonly addedText: string;
+  readonly removedText: string;
+  toJSON(): { old_text: string; new_text: string; hunks: Array<{ type: HunkType; text: string }> };
+  static fromJSON(data: Record<string, unknown>): TextDiff;
+}
+
+export function diffText(oldText: string | null | undefined, newText: string | null | undefined): TextDiff;
+
+// ── Change types ───────────────────────────────────────────────────────
+
+export const CHANGE_ADDED: 'added';
+export const CHANGE_REMOVED: 'removed';
+export const CHANGE_CHANGED: 'changed';
+
+export type ChangeType = typeof CHANGE_ADDED | typeof CHANGE_REMOVED | typeof CHANGE_CHANGED;
+
+export class Change extends GlossaristModel {
+  readonly type: ChangeType;
+  readonly path: string | null;
+}
+
+export class Added extends Change {
+  readonly type: 'added';
+  readonly value: unknown;
+  toJSON(): { type: 'added'; path?: string; value: unknown };
+  static fromJSON(data: Record<string, unknown>): Added;
+}
+
+export class Removed extends Change {
+  readonly type: 'removed';
+  readonly value: unknown;
+  toJSON(): { type: 'removed'; path?: string; value: unknown };
+  static fromJSON(data: Record<string, unknown>): Removed;
+}
+
+export class Changed extends Change {
+  readonly type: 'changed';
+  readonly oldValue: unknown;
+  readonly newValue: unknown;
+  readonly textDiff: TextDiff | null;
+  toJSON(): {
+    type: 'changed';
+    path?: string;
+    old_value: unknown;
+    new_value: unknown;
+    text_diff?: ReturnType<TextDiff['toJSON']>;
+  };
+  static fromJSON(data: Record<string, unknown>): Changed;
+}
+
+export function deserializeChange(data: Record<string, unknown>): Change;
+
+// ── List diff ──────────────────────────────────────────────────────────
+
+export interface DiffListOptions {
+  identityKey?: (item: any) => string;
+  textKey?: (item: any) => string | null;
+}
+
+export class ListDiff extends GlossaristModel {
+  readonly added: Added[];
+  readonly removed: Removed[];
+  readonly changed: Changed[];
+  readonly hasChanges: boolean;
+  readonly count: number;
+  entries(): Generator<Change, void, unknown>;
+  toJSON(): {
+    added: ReturnType<Added['toJSON']>[];
+    removed: ReturnType<Removed['toJSON']>[];
+    changed: ReturnType<Changed['toJSON']>[];
+  };
+  static fromJSON(data: Record<string, unknown>): ListDiff;
+}
+
+export function diffList(oldList: unknown[], newList: unknown[], options?: DiffListOptions): ListDiff;
+export function diffSet(oldList: unknown[], newList: unknown[], options: DiffListOptions): ListDiff;
+
+// ── Concept diff ───────────────────────────────────────────────────────
+
+export interface DiffWalkEntry {
+  path: string;
+  change: Change;
+}
+
+export interface ConceptDiffWalkEntry extends DiffWalkEntry {
+  language: string;
+}
+
+export class DiffStats extends GlossaristModel {
+  readonly added: number;
+  readonly removed: number;
+  readonly changed: number;
+  readonly total: number;
+  toJSON(): { added: number; removed: number; changed: number };
+  static fromJSON(data: Record<string, unknown>): DiffStats;
+}
+
+export class MetadataDiff extends GlossaristModel {
+  readonly changes: Record<string, Changed>;
+  readonly hasChanges: boolean;
+  readonly count: number;
+  walk(section?: string): Generator<DiffWalkEntry, void, unknown>;
+  toJSON(): Record<string, ReturnType<Changed['toJSON']>>;
+  static fromJSON(data: Record<string, unknown>): MetadataDiff;
+}
+
+export class ConceptLevelDiff extends GlossaristModel {
+  readonly sources: ListDiff;
+  readonly dates: ListDiff;
+  readonly relatedConcepts: ListDiff;
+  readonly groups: ListDiff;
+  readonly sections: ListDiff;
+  readonly tags: ListDiff;
+  readonly metadata: MetadataDiff;
+  readonly hasChanges: boolean;
+  walk(): Generator<DiffWalkEntry, void, unknown>;
+  toJSON(): Record<string, unknown>;
+  static fromJSON(data: Record<string, unknown>): ConceptLevelDiff;
+}
+
+export class LocalizedConceptDiff extends GlossaristModel {
+  readonly languageCode: string | null;
+  readonly designations: ListDiff;
+  readonly definitions: ListDiff;
+  readonly notes: ListDiff;
+  readonly examples: ListDiff;
+  readonly sources: ListDiff;
+  readonly dates: ListDiff;
+  readonly related: ListDiff;
+  readonly metadata: MetadataDiff;
+  readonly hasChanges: boolean;
+  walk(prefix?: string): Generator<DiffWalkEntry, void, unknown>;
+  toJSON(): Record<string, unknown>;
+  static fromJSON(data: Record<string, unknown>): LocalizedConceptDiff;
+}
+
+export class ConceptDiff extends GlossaristModel {
+  readonly oldId: string | null;
+  readonly newId: string | null;
+  readonly concept: ConceptLevelDiff;
+  readonly languages: ListDiff;
+  readonly localizations: Record<string, LocalizedConceptDiff>;
+  readonly hasChanges: boolean;
+  readonly localizationLanguages: string[];
+  readonly stats: DiffStats;
+  localization(lang: string): LocalizedConceptDiff | null;
+  walk(): Generator<ConceptDiffWalkEntry, void, unknown>;
+  toJSON(): Record<string, unknown>;
+  static fromJSON(data: Record<string, unknown>): ConceptDiff;
+}
+
+export function diffConcepts(
+  oldConcept: any | null,
+  newConcept: any | null,
+  language?: string,
+): ConceptDiff;
+
+export function diffLocalizedConcepts(
+  oldLoc: any | null,
+  newLoc: any | null,
+): LocalizedConceptDiff;

package/src/diff/index.js

@@ -0,0 +1,48 @@
+export {
+  TextHunk,
+  TextDiff,
+  diffText,
+} from './text-diff.js';
+
+export {
+  Change,
+  Added,
+  Removed,
+  Changed,
+  CHANGE_ADDED,
+  CHANGE_REMOVED,
+  CHANGE_CHANGED,
+  deserializeChange,
+} from './change.js';
+
+export {
+  ListDiff,
+  diffList,
+  diffSet,
+} from './list-diff.js';
+
+export {
+  DiffStats,
+  MetadataDiff,
+  ConceptLevelDiff,
+  LocalizedConceptDiff,
+  ConceptDiff,
+  diffConcepts,
+  diffLocalizedConcepts,
+} from './concept-diff.js';
+
+export {
+  ConceptCollectionDiff,
+  diffConceptCollections,
+} from './collection-diff.js';
+
+export {
+  renderConceptDiff,
+  renderCollectionDiff,
+  renderTextDiff,
+} from './diff-renderer.js';
+
+export {
+  applyDiff,
+  reverseDiff,
+} from './diff-patch.js';