@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/dictionary-csv/dictionaryCsv.js

@@ -0,0 +1,150 @@
+import { DictionaryKind } from "../../engine/modules/dictionary/actions.js";
+import { parseCsv, serializeCsv } from "./csv.js";
+//#region src/utils/dictionary-csv/dictionaryCsv.ts
+var DictionaryCsvFormat = {
+	own: "own",
+	publicStandard: "publicStandard"
+};
+var DictionaryCsvColumns = {
+	[DictionaryKind.word]: [
+		"name",
+		"abbreviation",
+		"englishName",
+		"description",
+		"synonyms",
+		"forbiddenWords"
+	],
+	[DictionaryKind.term]: [
+		"name",
+		"physicalName",
+		"domain",
+		"description",
+		"synonyms"
+	],
+	[DictionaryKind.domain]: [
+		"name",
+		"category",
+		"dataType",
+		"description"
+	]
+};
+var STANDARD_DATA_TYPE = "데이터타입";
+var STANDARD_DATA_LENGTH = "데이터길이";
+var STANDARD_DATA_SCALE = "데이터소수점길이";
+var LAYOUTS = [
+	{
+		kind: DictionaryKind.word,
+		format: DictionaryCsvFormat.own,
+		keys: ["name", "abbreviation"],
+		fields: DictionaryCsvColumns.word,
+		headers: DictionaryCsvColumns.word
+	},
+	{
+		kind: DictionaryKind.term,
+		format: DictionaryCsvFormat.own,
+		keys: ["name", "physicalName"],
+		fields: DictionaryCsvColumns.term,
+		headers: DictionaryCsvColumns.term
+	},
+	{
+		kind: DictionaryKind.domain,
+		format: DictionaryCsvFormat.own,
+		keys: ["name", "dataType"],
+		fields: DictionaryCsvColumns.domain,
+		headers: DictionaryCsvColumns.domain
+	},
+	{
+		kind: DictionaryKind.word,
+		format: DictionaryCsvFormat.publicStandard,
+		keys: ["공통표준단어명"],
+		fields: DictionaryCsvColumns.word,
+		headers: [
+			"공통표준단어명",
+			"공통표준단어영문약어명",
+			"공통표준단어 영문명",
+			"공통표준단어 설명",
+			"이음동의어 목록",
+			"금칙어 목록"
+		]
+	},
+	{
+		kind: DictionaryKind.term,
+		format: DictionaryCsvFormat.publicStandard,
+		keys: ["공통표준용어명"],
+		fields: DictionaryCsvColumns.term,
+		headers: [
+			"공통표준용어명",
+			"공통표준용어영문약어명",
+			"공통표준도메인명",
+			"공통표준용어설명",
+			"용어 이음동의어 목록"
+		]
+	},
+	{
+		kind: DictionaryKind.domain,
+		format: DictionaryCsvFormat.publicStandard,
+		keys: ["공통표준도메인명", STANDARD_DATA_TYPE],
+		fields: DictionaryCsvColumns.domain,
+		headers: [
+			"공통표준도메인명",
+			"공통표준도메인분류명",
+			STANDARD_DATA_TYPE,
+			"공통표준도메인설명"
+		]
+	}
+];
+function normalizeHeader(header) {
+	return header.normalize("NFC").replace(/\s/g, "");
+}
+function findLayout(positions) {
+	const found = LAYOUTS.filter((layout) => layout.keys.every((key) => positions.has(normalizeHeader(key))));
+	return found.length === 1 ? found[0] : null;
+}
+function toStandardDataType(type, length, scale) {
+	if (!type || !length) return type;
+	return /^0*$/.test(scale) ? `${type}(${length})` : `${type}(${length},${scale})`;
+}
+function readDictionaryCsv(text) {
+	const [header, ...records] = parseCsv(text);
+	if (!header) return null;
+	const positions = /* @__PURE__ */ new Map();
+	header.forEach((cell, index) => {
+		const name = normalizeHeader(cell);
+		if (!positions.has(name)) positions.set(name, index);
+	});
+	const layout = findLayout(positions);
+	if (!layout) return null;
+	const standard = layout.format === DictionaryCsvFormat.publicStandard;
+	const columns = layout.fields.flatMap((field, index) => {
+		const at = positions.get(normalizeHeader(layout.headers[index]));
+		return at === void 0 ? [] : [[field, at]];
+	});
+	const typeParts = standard && layout.kind === DictionaryKind.domain ? [positions.get(normalizeHeader(STANDARD_DATA_LENGTH)), positions.get(normalizeHeader(STANDARD_DATA_SCALE))] : null;
+	const cellOf = (record, at) => {
+		const cell = at === void 0 ? "" : record[at] ?? "";
+		return standard ? cell.trim() : cell;
+	};
+	const rows = [];
+	let skipped = 0;
+	for (const record of records) {
+		if (record.every((cell) => !cell.trim())) continue;
+		const row = {};
+		for (const [field, at] of columns) row[field] = cellOf(record, at);
+		if (typeParts) row.dataType = toStandardDataType(row.dataType, cellOf(record, typeParts[0]), cellOf(record, typeParts[1]));
+		if (row.name.trim()) rows.push(row);
+		else skipped++;
+	}
+	return {
+		kind: layout.kind,
+		format: layout.format,
+		fields: columns.map(([field]) => field),
+		rows,
+		skipped
+	};
+}
+function writeDictionaryCsv(kind, rows) {
+	const fields = DictionaryCsvColumns[kind];
+	return serializeCsv([fields, ...rows.map((row) => fields.map((field) => row[field]))]);
+}
+//#endregion
+export { DictionaryCsvColumns, DictionaryCsvFormat, readDictionaryCsv, writeDictionaryCsv };

package/dist/utils/diff/compareEntities.js

@@ -0,0 +1,200 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, OrderType } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { getTableGroupMemberIds } from "../tableGroup.js";
+import { asNextId } from "./pairEntities.js";
+import { DiffField } from "./types.js";
+//#region src/utils/diff/compareEntities.ts
+var point = (x, y) => `${Math.round(x)}, ${Math.round(y)}`;
+var size = (width, height) => `${Math.round(width)} × ${Math.round(height)}`;
+function changesOf(pairs) {
+	return pairs.filter(([, before, after]) => before !== after).map(([field, before, after]) => ({
+		field,
+		before,
+		after
+	}));
+}
+function changeShown(field, same, before, after) {
+	return same ? [] : [{
+		field,
+		before,
+		after
+	}];
+}
+var columnName = (state, id) => query(state.collections).collection("tableColumnEntities").selectById(id)?.name ?? "";
+var tableName = (state, id) => query(state.collections).collection("tableEntities").selectById(id)?.name ?? "";
+var groupOf = (state, table) => table.groupId && state.doc.tableGroupIds.includes(table.groupId) ? table.groupId : "";
+var groupName = (state, id) => id ? query(state.collections).collection("tableGroupEntities").selectById(id)?.name ?? "" : "";
+function compareTables(ctx, prev, next) {
+	const prevGroup = groupOf(ctx.prev, prev);
+	const nextGroup = groupOf(ctx.next, next);
+	const pairedGroup = prevGroup ? asNextId(ctx.tableGroups, prevGroup, "prev") : "";
+	return [
+		...changesOf([[
+			DiffField.name,
+			prev.name,
+			next.name
+		], [
+			DiffField.comment,
+			prev.comment,
+			next.comment
+		]]),
+		...changeShown(DiffField.tableGroup, pairedGroup === nextGroup, groupName(ctx.prev, prevGroup), groupName(ctx.next, nextGroup)),
+		...changesOf([[
+			DiffField.position,
+			point(prev.ui.x, prev.ui.y),
+			point(next.ui.x, next.ui.y)
+		], [
+			DiffField.color,
+			prev.ui.color,
+			next.ui.color
+		]])
+	];
+}
+var OPTIONS = [
+	[DiffField.autoIncrement, ColumnOption.autoIncrement],
+	[DiffField.primaryKey, ColumnOption.primaryKey],
+	[DiffField.unique, ColumnOption.unique],
+	[DiffField.notNull, ColumnOption.notNull]
+];
+function compareColumns(prev, next, moved) {
+	return [...changesOf([
+		[
+			DiffField.name,
+			prev.name,
+			next.name
+		],
+		[
+			DiffField.comment,
+			prev.comment,
+			next.comment
+		],
+		[
+			DiffField.dataType,
+			prev.dataType,
+			next.dataType
+		],
+		[
+			DiffField.default,
+			prev.default,
+			next.default
+		],
+		...OPTIONS.map(([field, bit]) => [
+			field,
+			bHas(prev.options, bit),
+			bHas(next.options, bit)
+		])
+	]), ...moved ? [{
+		field: DiffField.order,
+		before: moved.before,
+		after: moved.after
+	}] : []];
+}
+var keyColumnsOf = (state, index) => query(state.collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).map(({ columnId, orderType }) => ({
+	id: columnId,
+	descending: orderType === OrderType.DESC
+}));
+var keyColumnsText = (state, columns) => columns.map(({ id, descending }) => {
+	const name = columnName(state, id);
+	return descending ? `${name} DESC` : name;
+}).join(", ");
+function indexKeyOf(ctx, index, side) {
+	return keyColumnsOf(ctx[side], index).map(({ id, descending }) => `${asNextId(ctx.columns, id, side)}${descending ? " DESC" : ""}`).join(",");
+}
+function compareIndexes(ctx, prev, next) {
+	return [...changesOf([[
+		DiffField.name,
+		prev.name,
+		next.name
+	], [
+		DiffField.unique,
+		prev.unique,
+		next.unique
+	]]), ...changeShown(DiffField.columns, indexKeyOf(ctx, prev, "prev") === indexKeyOf(ctx, next, "next"), keyColumnsText(ctx.prev, keyColumnsOf(ctx.prev, prev)), keyColumnsText(ctx.next, keyColumnsOf(ctx.next, next)))];
+}
+function foreignKeyText(state, relationship) {
+	const names = (ids) => ids.map((id) => columnName(state, id)).join(", ");
+	return `${names(relationship.end.columnIds)} → ${tableName(state, relationship.start.tableId)}(${names(relationship.start.columnIds)})`;
+}
+function foreignKeyPairsOf(ctx, relationship, side) {
+	const as = (id) => asNextId(ctx.columns, id, side);
+	return relationship.end.columnIds.map((id, index) => `${as(id)}>${as(relationship.start.columnIds[index] ?? "")}`).sort().join(",");
+}
+function compareForeignKeys(ctx, prev, next) {
+	return [...changeShown(DiffField.columns, foreignKeyPairsOf(ctx, prev, "prev") === foreignKeyPairsOf(ctx, next, "next"), foreignKeyText(ctx.prev, prev), foreignKeyText(ctx.next, next)), ...changesOf([
+		[
+			DiffField.relationshipType,
+			prev.relationshipType,
+			next.relationshipType
+		],
+		[
+			DiffField.onDelete,
+			prev.onDelete,
+			next.onDelete
+		],
+		[
+			DiffField.onUpdate,
+			prev.onUpdate,
+			next.onUpdate
+		]
+	])];
+}
+function compareMemos(prev, next) {
+	return changesOf([
+		[
+			DiffField.value,
+			prev.value,
+			next.value
+		],
+		[
+			DiffField.position,
+			point(prev.ui.x, prev.ui.y),
+			point(next.ui.x, next.ui.y)
+		],
+		[
+			DiffField.size,
+			size(prev.ui.width, prev.ui.height),
+			size(next.ui.width, next.ui.height)
+		],
+		[
+			DiffField.color,
+			prev.ui.color,
+			next.ui.color
+		]
+	]);
+}
+function groupMembersOf(ctx, group, side) {
+	return getTableGroupMemberIds(ctx[side], group.id).map((id) => asNextId(ctx.tables, id, side));
+}
+var memberNames = (state, group) => getTableGroupMemberIds(state, group.id).map((id) => tableName(state, id)).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase())).join(", ");
+function compareTableGroups(ctx, prev, next) {
+	const before = groupMembersOf(ctx, prev, "prev").sort().join(",");
+	const after = groupMembersOf(ctx, next, "next").sort().join(",");
+	return [
+		...changesOf([[
+			DiffField.name,
+			prev.name,
+			next.name
+		]]),
+		...changeShown(DiffField.members, before === after, memberNames(ctx.prev, prev), memberNames(ctx.next, next)),
+		...changesOf([
+			[
+				DiffField.color,
+				prev.color,
+				next.color
+			],
+			[
+				DiffField.position,
+				point(prev.ui.x, prev.ui.y),
+				point(next.ui.x, next.ui.y)
+			],
+			[
+				DiffField.size,
+				size(prev.ui.width, prev.ui.height),
+				size(next.ui.width, next.ui.height)
+			]
+		])
+	];
+}
+//#endregion
+export { compareColumns, compareForeignKeys, compareIndexes, compareMemos, compareTableGroups, compareTables, foreignKeyPairsOf, foreignKeyText, groupMembersOf, indexKeyOf };

package/dist/{components/erd/diff-viewer → utils/diff}/diff.d.ts

@@ -1,4 +1,4 @@
-import { Theme } from '../../../themes/tokens';
+import { Theme } from '../../themes/tokens';
 /** The kinds of change a diff pane marks, one bit each. */
 export declare const Diff: {
     readonly insert: 1;

package/dist/utils/diff/diff.js

@@ -0,0 +1,29 @@
+//#region src/utils/diff/diff.ts
+var Diff = {
+	insert: 1,
+	delete: 2,
+	modify: 4,
+	rename: 8
+};
+var ENTITY_PATH = "entity";
+var MEMO_VALUE_PATH = "memoValue";
+var COLUMN_KEY_PATH = "columnPrimaryKey";
+var TABLE_GROUP_NAME_PATH = "tableGroupName";
+function foreground(theme, diff) {
+	switch (diff) {
+		case Diff.insert: return theme.diffInsertForeground;
+		case Diff.delete: return theme.diffDeleteForeground;
+		case Diff.modify: return theme.diffModifyForeground;
+		case Diff.rename: return theme.diffRenameForeground;
+		default: return null;
+	}
+}
+function diffTextColor(theme, paths, path, row = false) {
+	if (!paths) return null;
+	return foreground(theme, paths.get(path)) ?? (row ? foreground(theme, paths.get("entity")) : null);
+}
+function diffOutline(theme, paths) {
+	return foreground(theme, paths?.get(ENTITY_PATH));
+}
+//#endregion
+export { COLUMN_KEY_PATH, Diff, ENTITY_PATH, MEMO_VALUE_PATH, TABLE_GROUP_NAME_PATH, diffOutline, diffTextColor };

package/dist/utils/diff/diffDocuments.js

@@ -0,0 +1,224 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { FocusType } from "../../engine/modules/editor/state.js";
+import { orderByNameASC } from "../tableName.js";
+import { getTableIndexIds } from "../tableKeys.js";
+import { COLUMN_KEY_PATH, Diff, ENTITY_PATH, MEMO_VALUE_PATH, TABLE_GROUP_NAME_PATH } from "./diff.js";
+import { longestCommonIndexes, pairByOverlap, pairEntities } from "./pairEntities.js";
+import { DiffField, DiffKind, DiffStatus } from "./types.js";
+import { compareColumns, compareForeignKeys, compareIndexes, compareMemos, compareTableGroups, compareTables, foreignKeyPairsOf, foreignKeyText, groupMembersOf, indexKeyOf } from "./compareEntities.js";
+//#region src/utils/diff/diffDocuments.ts
+function liveOf(state) {
+	const { doc, collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(doc.tableIds);
+	const tableIds = new Set(doc.tableIds);
+	return {
+		tables,
+		columns: tables.flatMap((table) => query(collections).collection("tableColumnEntities").selectByIds(table.columnIds)),
+		indexes: tables.flatMap((table) => query(collections).collection("indexEntities").selectByIds(getTableIndexIds(state, table.id))),
+		relationships: query(collections).collection("relationshipEntities").selectByIds(doc.relationshipIds).filter(({ start, end }) => tableIds.has(start.tableId) && tableIds.has(end.tableId)),
+		memos: query(collections).collection("memoEntities").selectByIds(doc.memoIds),
+		tableGroups: query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds)
+	};
+}
+var named = (name) => name.trim() ? name : null;
+var firstLine = (text) => text.split(/\r?\n/, 1)[0].trim();
+function statusOf(changes) {
+	if (changes.some(({ field }) => field === DiffField.name)) return DiffStatus.renamed;
+	return changes.length ? DiffStatus.modified : null;
+}
+function entry(kind, status, prev, next, changes = [], children = []) {
+	return {
+		kind,
+		status,
+		prevId: prev?.id ?? null,
+		nextId: next?.id ?? null,
+		name: (next ?? prev).name,
+		prevName: (prev ?? next).name,
+		logicalName: (next ?? prev).logicalName ?? "",
+		prevLogicalName: (prev ?? next).logicalName ?? "",
+		changes,
+		children
+	};
+}
+function inPlace(kind, prev, next, pairing, compare, nameOf) {
+	const pairedEntry = (prevItem, nextItem) => {
+		const changes = compare(prevItem, nextItem);
+		const status = statusOf(changes);
+		return status ? entry(kind, status, nameOf(prevItem, "prev"), nameOf(nextItem, "next"), changes) : null;
+	};
+	const byNext = new Map(prev.map((item) => [pairing.toNext.get(item.id), item]));
+	const rows = next.map((item) => {
+		const before = byNext.get(item.id);
+		return {
+			nextId: item.id,
+			entry: before ? pairedEntry(before, item) : entry(kind, DiffStatus.added, null, nameOf(item, "next"))
+		};
+	});
+	let after = null;
+	for (const item of prev) {
+		const nextId = pairing.toNext.get(item.id);
+		if (nextId) {
+			after = nextId;
+			continue;
+		}
+		let insertAt = (after === null ? -1 : rows.findIndex((row) => row.nextId === after)) + 1;
+		while (insertAt < rows.length && rows[insertAt].nextId === null) insertAt++;
+		rows.splice(insertAt, 0, {
+			nextId: null,
+			entry: entry(kind, DiffStatus.deleted, nameOf(item, "prev"), null)
+		});
+	}
+	return rows.map(({ entry }) => entry).filter((value) => value !== null);
+}
+function listedByName(kind, prev, next, pairing, compare, childrenOf = () => []) {
+	const nextById = new Map(next.map((item) => [item.id, item]));
+	const entries = [];
+	for (const item of prev) {
+		const pairedId = pairing.toNext.get(item.id);
+		const paired = pairedId ? nextById.get(pairedId) : void 0;
+		if (!paired) {
+			entries.push(entry(kind, DiffStatus.deleted, item, null));
+			continue;
+		}
+		const changes = compare(item, paired);
+		const children = childrenOf(item, paired);
+		const status = statusOf(changes);
+		(status || children.length) && entries.push(entry(kind, status, item, paired, changes, children));
+	}
+	for (const item of next) pairing.toPrev.has(item.id) || entries.push(entry(kind, DiffStatus.added, null, item));
+	return entries.sort(orderByNameASC);
+}
+function tableChildren(ctx, pairs, live, prevTable, nextTable) {
+	const columnsOf = (state, table) => query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const prevColumns = columnsOf(ctx.prev, prevTable);
+	const nextColumns = columnsOf(ctx.next, nextTable);
+	const nextIds = new Set(nextColumns.map(({ id }) => id));
+	const prevOrder = prevColumns.map(({ id }) => ctx.columns.toNext.get(id)).filter((id) => Boolean(id && nextIds.has(id)));
+	const nextOrder = nextColumns.map(({ id }) => id).filter((id) => ctx.columns.toPrev.has(id));
+	const kept = longestCommonIndexes(prevOrder, nextOrder);
+	const moved = new Set(nextOrder.filter((_, index) => !kept.has(index)));
+	const placeOf = (columns, id) => columns.findIndex((column) => column.id === id) + 1;
+	const columns = inPlace(DiffKind.column, prevColumns, nextColumns, ctx.columns, (prev, next) => compareColumns(prev, next, moved.has(next.id) ? {
+		before: placeOf(prevColumns, prev.id),
+		after: placeOf(nextColumns, next.id)
+	} : null), (column) => column);
+	const indexesOf = (side, table) => side.indexes.filter(({ tableId }) => tableId === table.id);
+	const indexes = inPlace(DiffKind.index, indexesOf(live.prev, prevTable), indexesOf(live.next, nextTable), pairs.indexes, (prev, next) => compareIndexes(ctx, prev, next), (index) => index);
+	const foreignKeysOf = (side, table) => side.relationships.filter(({ end }) => end.tableId === table.id);
+	const foreignKeys = inPlace(DiffKind.foreignKey, foreignKeysOf(live.prev, prevTable), foreignKeysOf(live.next, nextTable), pairs.relationships, (prev, next) => compareForeignKeys(ctx, prev, next), (relationship, side) => ({
+		id: relationship.id,
+		name: foreignKeyText(ctx[side], relationship)
+	}));
+	return [
+		...columns,
+		...indexes,
+		...foreignKeys
+	];
+}
+var CELL_OF_FIELD = {
+	[DiffKind.table]: {
+		[DiffField.name]: FocusType.tableName,
+		[DiffField.comment]: FocusType.tableComment
+	},
+	[DiffKind.column]: {
+		[DiffField.name]: FocusType.columnName,
+		[DiffField.comment]: FocusType.columnComment,
+		[DiffField.dataType]: FocusType.columnDataType,
+		[DiffField.default]: FocusType.columnDefault,
+		[DiffField.autoIncrement]: FocusType.columnAutoIncrement,
+		[DiffField.primaryKey]: COLUMN_KEY_PATH,
+		[DiffField.unique]: FocusType.columnUnique,
+		[DiffField.notNull]: FocusType.columnNotNull
+	},
+	[DiffKind.memo]: { [DiffField.value]: MEMO_VALUE_PATH },
+	[DiffKind.tableGroup]: { [DiffField.name]: TABLE_GROUP_NAME_PATH }
+};
+var NAME_PATH = {
+	[DiffKind.table]: FocusType.tableName,
+	[DiffKind.tableGroup]: TABLE_GROUP_NAME_PATH
+};
+function mark(map, id, path, diff) {
+	const paths = map.get(id) ?? /* @__PURE__ */ new Map();
+	paths.set(path, diff);
+	map.set(id, paths);
+}
+function markEntry(diff, item) {
+	if (item.kind === DiffKind.index) return;
+	const name = NAME_PATH[item.kind];
+	if (item.status === DiffStatus.added && item.nextId) {
+		mark(diff.next, item.nextId, ENTITY_PATH, Diff.insert);
+		name && mark(diff.next, item.nextId, name, Diff.insert);
+		return;
+	}
+	if (item.status === DiffStatus.deleted && item.prevId) {
+		mark(diff.prev, item.prevId, ENTITY_PATH, Diff.delete);
+		name && mark(diff.prev, item.prevId, name, Diff.delete);
+		return;
+	}
+	for (const change of item.changes) {
+		const cell = CELL_OF_FIELD[item.kind]?.[change.field];
+		const path = cell ?? "entity";
+		const flag = change.field === DiffField.name && cell ? Diff.rename : Diff.modify;
+		item.prevId && mark(diff.prev, item.prevId, path, flag);
+		item.nextId && mark(diff.next, item.nextId, path, flag);
+	}
+}
+function diffDocuments(prev, next) {
+	const live = {
+		prev: liveOf(prev),
+		next: liveOf(next)
+	};
+	const tables = pairEntities(live.prev.tables, live.next.tables, [(table) => named(table.name)]);
+	const tableOf = (tableId, side) => side === "prev" ? tables.toNext.get(tableId) : tableId;
+	const byTableAndName = (item, side) => {
+		const name = named(item.name);
+		const table = tableOf(item.tableId, side);
+		return name && table ? `${table}|${name}` : null;
+	};
+	const ctx = {
+		prev,
+		next,
+		tables,
+		columns: pairEntities(live.prev.columns, live.next.columns, [byTableAndName]),
+		tableGroups: pairEntities(live.prev.tableGroups, live.next.tableGroups, [(group) => named(group.name)])
+	};
+	pairByOverlap(ctx.tableGroups, live.prev.tableGroups.filter((group) => named(group.name) === null), live.next.tableGroups.filter((group) => named(group.name) === null), (group, side) => groupMembersOf(ctx, group, side));
+	const indexes = pairEntities(live.prev.indexes, live.next.indexes, [byTableAndName, (index, side) => {
+		const table = tableOf(index.tableId, side);
+		return named(index.name) === null && table ? `${table}|${indexKeyOf(ctx, index, side)}|${index.unique}` : null;
+	}]);
+	const relationships = pairEntities(live.prev.relationships, live.next.relationships, [(relationship, side) => {
+		const parent = tableOf(relationship.start.tableId, side);
+		const child = tableOf(relationship.end.tableId, side);
+		return parent && child ? `${parent}|${child}|${foreignKeyPairsOf(ctx, relationship, side)}` : null;
+	}]);
+	const memos = pairEntities(live.prev.memos, live.next.memos, [(memo) => memo.value ? memo.value : null, (memo) => `${Math.round(memo.ui.x)},${Math.round(memo.ui.y)}`]);
+	const tableEntries = listedByName(DiffKind.table, live.prev.tables, live.next.tables, ctx.tables, (prevTable, nextTable) => compareTables(ctx, prevTable, nextTable), (prevTable, nextTable) => tableChildren(ctx, {
+		indexes,
+		relationships
+	}, live, prevTable, nextTable));
+	const groupEntries = listedByName(DiffKind.tableGroup, live.prev.tableGroups, live.next.tableGroups, ctx.tableGroups, (prevGroup, nextGroup) => compareTableGroups(ctx, prevGroup, nextGroup));
+	const memoEntries = inPlace(DiffKind.memo, live.prev.memos, live.next.memos, memos, compareMemos, (memo) => ({
+		id: memo.id,
+		name: firstLine(memo.value)
+	}));
+	const diff = {
+		entries: {
+			tables: tableEntries,
+			tableGroups: groupEntries,
+			memos: memoEntries
+		},
+		prev: /* @__PURE__ */ new Map(),
+		next: /* @__PURE__ */ new Map()
+	};
+	const walk = (items) => items.forEach((item) => {
+		markEntry(diff, item);
+		walk(item.children);
+	});
+	walk(tableEntries);
+	walk(groupEntries);
+	walk(memoEntries);
+	return diff;
+}
+//#endregion
+export { diffDocuments };

package/dist/utils/diff/pairEntities.js

@@ -0,0 +1,71 @@
+//#region src/utils/diff/pairEntities.ts
+var emptyPairing = () => ({
+	toNext: /* @__PURE__ */ new Map(),
+	toPrev: /* @__PURE__ */ new Map()
+});
+function asNextId(pairing, id, side) {
+	return side === "next" ? id : pairing.toNext.get(id) ?? `prev:${id}`;
+}
+function link(pairing, prevId, nextId) {
+	pairing.toNext.set(prevId, nextId);
+	pairing.toPrev.set(nextId, prevId);
+}
+function pairEntities(prev, next, keys = []) {
+	const pairing = emptyPairing();
+	const nextIds = new Set(next.map(({ id }) => id));
+	for (const { id } of prev) nextIds.has(id) && link(pairing, id, id);
+	for (const key of keys) {
+		const waiting = /* @__PURE__ */ new Map();
+		for (const item of next) {
+			if (pairing.toPrev.has(item.id)) continue;
+			const value = key(item, "next");
+			if (value === null) continue;
+			const list = waiting.get(value);
+			list ? list.push(item) : waiting.set(value, [item]);
+		}
+		for (const item of prev) {
+			if (pairing.toNext.has(item.id)) continue;
+			const value = key(item, "prev");
+			const match = value === null ? void 0 : waiting.get(value)?.shift();
+			match && link(pairing, item.id, match.id);
+		}
+	}
+	return pairing;
+}
+function pairByOverlap(pairing, prev, next, membersOf) {
+	const open = next.filter(({ id }) => !pairing.toPrev.has(id));
+	for (const item of prev) {
+		if (pairing.toNext.has(item.id)) continue;
+		const members = new Set(membersOf(item, "prev"));
+		if (!members.size) continue;
+		let best = null;
+		let most = 0;
+		for (const candidate of open) {
+			if (pairing.toPrev.has(candidate.id)) continue;
+			const shared = membersOf(candidate, "next").filter((id) => members.has(id)).length;
+			if (shared > most) {
+				best = candidate;
+				most = shared;
+			}
+		}
+		best && link(pairing, item.id, best.id);
+	}
+}
+function longestCommonIndexes(a, b) {
+	const rows = a.length + 1;
+	const cols = b.length + 1;
+	const table = new Uint32Array(rows * cols);
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) table[i * cols + j] = a[i] === b[j] ? table[(i + 1) * cols + j + 1] + 1 : Math.max(table[(i + 1) * cols + j], table[i * cols + j + 1]);
+	const kept = /* @__PURE__ */ new Set();
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) if (a[i] === b[j]) {
+		kept.add(j);
+		i++;
+		j++;
+	} else if (table[(i + 1) * cols + j] >= table[i * cols + j + 1]) i++;
+	else j++;
+	return kept;
+}
+//#endregion
+export { asNextId, emptyPairing, longestCommonIndexes, pairByOverlap, pairEntities };

package/dist/utils/diff/types.d.ts

@@ -1,5 +1,5 @@
-import { DiffMap } from '../../components/erd/diff-viewer/diff';
 import { ValuesType } from '../../internal-types';
+import { DiffMap } from './diff';
 export declare const DiffKind: {
     readonly table: "table";
     readonly column: "column";