@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/engine/modules/index/atom.actions.js

@@ -0,0 +1,73 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { invalidateTableIndexes } from "../../../utils/tableKeys.js";
+import { ActionType } from "./actions.js";
+import { createIndex } from "../../../utils/collection/index.entity.js";
+//#region src/engine/modules/index/atom.actions.ts
+var addIndexAction = createAction(ActionType.addIndex);
+var addIndex = ({ doc, collections, lww }, { payload: { id, tableId }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("indexEntities").addOne(createIndex({
+		id,
+		tableId
+	})).addOperator(lww, safeVersion, id, () => {
+		if (!arrayHas(doc.indexIds)(id)) {
+			doc.indexIds.push(id);
+			invalidateTableIndexes();
+		}
+	});
+};
+var removeIndexAction = createAction(ActionType.removeIndex);
+var removeIndex = ({ doc, collections, lww }, { payload: { id }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("indexEntities").removeOperator(lww, safeVersion, id, () => {
+		const index = doc.indexIds.indexOf(id);
+		if (index !== -1) {
+			doc.indexIds.splice(index, 1);
+			invalidateTableIndexes();
+		}
+	});
+};
+var changeIndexNameAction = createAction(ActionType.changeIndexName);
+var changeIndexName = ({ collections, lww }, { payload: { id, tableId, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("indexEntities");
+	collection.getOrCreate(id, (id) => createIndex({
+		id,
+		tableId
+	}));
+	collection.replaceOperator(lww, safeVersion, id, "name", () => {
+		collection.updateOne(id, (index) => {
+			index.name = value;
+		});
+	});
+};
+var changeIndexUniqueAction = createAction(ActionType.changeIndexUnique);
+var changeIndexUnique = ({ collections, lww }, { payload: { id, tableId, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("indexEntities");
+	collection.getOrCreate(id, (id) => createIndex({
+		id,
+		tableId
+	}));
+	collection.replaceOperator(lww, safeVersion, id, "unique", () => {
+		collection.updateOne(id, (index) => {
+			index.unique = value;
+		});
+	});
+};
+var indexReducers = {
+	[ActionType.addIndex]: addIndex,
+	[ActionType.removeIndex]: removeIndex,
+	[ActionType.changeIndexName]: changeIndexName,
+	[ActionType.changeIndexUnique]: changeIndexUnique
+};
+var actions = {
+	addIndexAction,
+	removeIndexAction,
+	changeIndexNameAction,
+	changeIndexUniqueAction
+};
+//#endregion
+export { actions, addIndexAction, changeIndexNameAction, changeIndexUniqueAction, indexReducers, removeIndexAction };

package/dist/engine/modules/index/generator.actions.js

@@ -0,0 +1,25 @@
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { addIndexAction, changeIndexUniqueAction } from "./atom.actions.js";
+//#region src/engine/modules/index/generator.actions.ts
+var addIndexAction$ = (tableId) => function* () {
+	yield addIndexAction({
+		id: uuid25(),
+		tableId
+	});
+};
+var changeIndexUniqueAction$ = (indexId) => function* ({ collections }) {
+	const index = query(collections).collection("indexEntities").selectById(indexId);
+	if (!index) return;
+	yield changeIndexUniqueAction({
+		id: indexId,
+		tableId: index.tableId,
+		value: !index.unique
+	});
+};
+var actions$ = {
+	addIndexAction$,
+	changeIndexUniqueAction$
+};
+//#endregion
+export { actions$, addIndexAction$, changeIndexUniqueAction$ };

package/dist/engine/modules/index/history.js

@@ -0,0 +1,40 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ActionType } from "./actions.js";
+import { addIndexAction, changeIndexNameAction, changeIndexUniqueAction, removeIndexAction } from "./atom.actions.js";
+//#region src/engine/modules/index/history.ts
+var addIndex = (undoActions, { payload: { id } }) => {
+	undoActions.push(removeIndexAction({ id }));
+};
+var removeIndex = (undoActions, { payload: { id } }, { collections }) => {
+	const index = query(collections).collection("indexEntities").selectById(id);
+	if (!index) return;
+	undoActions.push(addIndexAction({
+		id,
+		tableId: index.tableId
+	}));
+};
+var changeIndexName = (undoActions, { payload: { id, tableId } }, { collections }) => {
+	const index = query(collections).collection("indexEntities").selectById(id);
+	if (!index) return;
+	undoActions.push(changeIndexNameAction({
+		id,
+		tableId,
+		value: index.name
+	}));
+};
+var changeIndexUnique = (undoActions, { payload: { id, tableId, value } }, { collections }) => {
+	if (!query(collections).collection("indexEntities").selectById(id)) return;
+	undoActions.push(changeIndexUniqueAction({
+		id,
+		tableId,
+		value: !value
+	}));
+};
+var indexPushUndoHistoryMap = {
+	[ActionType.addIndex]: addIndex,
+	[ActionType.removeIndex]: removeIndex,
+	[ActionType.changeIndexName]: changeIndexName,
+	[ActionType.changeIndexUnique]: changeIndexUnique
+};
+//#endregion
+export { indexPushUndoHistoryMap };

package/dist/engine/modules/index-column/actions.js

@@ -0,0 +1,9 @@
+//#region src/engine/modules/index-column/actions.ts
+var ActionType = {
+	addIndexColumn: "indexColumn.add",
+	removeIndexColumn: "indexColumn.remove",
+	moveIndexColumn: "indexColumn.move",
+	changeIndexColumnOrderType: "indexColumn.changeOrderType"
+};
+//#endregion
+export { ActionType };

package/dist/engine/modules/index-column/atom.actions.js

@@ -0,0 +1,93 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { addAndSort } from "../../../utils/collection/sequence.js";
+import { createIndex } from "../../../utils/collection/index.entity.js";
+import { ActionType } from "./actions.js";
+import { createIndexColumn } from "../../../utils/collection/indexColumn.entity.js";
+//#region src/engine/modules/index-column/atom.actions.ts
+var addIndexColumnAction = createAction(ActionType.addIndexColumn);
+var addIndexColumn = ({ collections, lww }, { payload: { id, indexId, tableId, columnId }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const indexCollection = query(collections).collection("indexEntities");
+	const index = indexCollection.getOrCreate(indexId, (id) => createIndex({
+		id,
+		tableId
+	}));
+	query(collections).collection("indexColumnEntities").addOne(createIndexColumn({
+		id,
+		indexId,
+		columnId
+	})).addOperator(lww, safeVersion, id, () => {
+		if (!arrayHas(index.indexColumnIds)(id)) indexCollection.updateOne(indexId, (index) => {
+			addAndSort(index.indexColumnIds, index.seqIndexColumnIds, id);
+		});
+	});
+};
+var removeIndexColumnAction = createAction(ActionType.removeIndexColumn);
+var removeIndexColumn = ({ collections, lww }, { payload: { id, indexId, tableId }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const indexCollection = query(collections).collection("indexEntities");
+	const index = indexCollection.getOrCreate(indexId, (id) => createIndex({
+		id,
+		tableId
+	}));
+	query(collections).collection("indexColumnEntities").removeOperator(lww, safeVersion, id, () => {
+		const i = index.indexColumnIds.indexOf(id);
+		if (i !== -1) indexCollection.updateOne(indexId, (index) => {
+			index.indexColumnIds.splice(i, 1);
+		});
+	});
+};
+var moveIndexColumnAction = createAction(ActionType.moveIndexColumn);
+var moveIndexColumn = ({ collections }, { payload: { id, indexId, tableId, targetId } }) => {
+	if (id === targetId) return;
+	const indexCollection = query(collections).collection("indexEntities");
+	const index = indexCollection.getOrCreate(indexId, (id) => createIndex({
+		id,
+		tableId
+	}));
+	const i = index.indexColumnIds.indexOf(id);
+	if (i === -1) return;
+	const targetIndex = index.indexColumnIds.indexOf(targetId);
+	if (targetIndex === -1) return;
+	indexCollection.updateOne(indexId, (index) => {
+		index.indexColumnIds.splice(i, 1);
+		index.indexColumnIds.splice(targetIndex, 0, id);
+		const seqIndex = index.seqIndexColumnIds.indexOf(id);
+		const seqTargetIndex = index.seqIndexColumnIds.indexOf(targetId);
+		if (seqIndex !== -1 && seqTargetIndex !== -1) {
+			index.seqIndexColumnIds.splice(seqIndex, 1);
+			index.seqIndexColumnIds.splice(seqTargetIndex, 0, id);
+		}
+	});
+};
+var changeIndexColumnOrderTypeAction = createAction(ActionType.changeIndexColumnOrderType);
+var changeIndexColumnOrderType = ({ collections, lww }, { payload: { id, indexId, columnId, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("indexColumnEntities");
+	collection.getOrCreate(id, (id) => createIndexColumn({
+		id,
+		indexId,
+		columnId
+	}));
+	collection.replaceOperator(lww, safeVersion, id, "orderType", () => {
+		collection.updateOne(id, (indexColumn) => {
+			indexColumn.orderType = value;
+		});
+	});
+};
+var indexColumnReducers = {
+	[ActionType.addIndexColumn]: addIndexColumn,
+	[ActionType.removeIndexColumn]: removeIndexColumn,
+	[ActionType.moveIndexColumn]: moveIndexColumn,
+	[ActionType.changeIndexColumnOrderType]: changeIndexColumnOrderType
+};
+var actions = {
+	addIndexColumnAction,
+	removeIndexColumnAction,
+	moveIndexColumnAction,
+	changeIndexColumnOrderTypeAction
+};
+//#endregion
+export { actions, addIndexColumnAction, changeIndexColumnOrderTypeAction, indexColumnReducers, moveIndexColumnAction, removeIndexColumnAction };

package/dist/engine/modules/index-column/generator.actions.js

@@ -0,0 +1,63 @@
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { OrderType } from "../../../constants/schema.js";
+import { addIndexColumnAction, changeIndexColumnOrderTypeAction, moveIndexColumnAction, removeIndexColumnAction } from "./atom.actions.js";
+//#region src/engine/modules/index-column/generator.actions.ts
+var addIndexColumnAction$ = (indexId, columnId) => function* ({ collections }) {
+	const index = query(collections).collection("indexEntities").selectById(indexId);
+	if (!index) return;
+	const prevIndexColumn = query(collections).collection("indexColumnEntities").selectByIds(index.seqIndexColumnIds).find((indexColumn) => indexColumn.columnId === columnId);
+	if (prevIndexColumn) yield addIndexColumnAction({
+		id: prevIndexColumn.id,
+		indexId,
+		tableId: index.tableId,
+		columnId
+	});
+	else yield addIndexColumnAction({
+		id: uuid25(),
+		indexId,
+		tableId: index.tableId,
+		columnId
+	});
+};
+var removeIndexColumnAction$ = (indexId, columnId) => function* ({ collections }) {
+	const index = query(collections).collection("indexEntities").selectById(indexId);
+	if (!index) return;
+	const indexColumns = query(collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).filter((indexColumn) => indexColumn.columnId === columnId);
+	for (const indexColumn of indexColumns) yield removeIndexColumnAction({
+		id: indexColumn.id,
+		indexId,
+		tableId: index.tableId
+	});
+};
+var changeIndexColumnOrderTypeAction$ = (indexColumnId) => function* ({ collections }) {
+	const indexColumn = query(collections).collection("indexColumnEntities").selectById(indexColumnId);
+	if (!indexColumn) return;
+	yield changeIndexColumnOrderTypeAction({
+		id: indexColumnId,
+		indexId: indexColumn.indexId,
+		columnId: indexColumn.columnId,
+		value: indexColumn.orderType === OrderType.ASC ? OrderType.DESC : OrderType.ASC
+	});
+};
+var moveIndexColumnAction$ = (indexColumnId, targetId) => function* ({ collections }) {
+	if (indexColumnId === targetId) return;
+	const indexColumn = query(collections).collection("indexColumnEntities").selectById(indexColumnId);
+	if (!indexColumn) return;
+	const index = query(collections).collection("indexEntities").selectById(indexColumn.indexId);
+	if (!index) return;
+	yield moveIndexColumnAction({
+		id: indexColumnId,
+		indexId: indexColumn.indexId,
+		tableId: index.tableId,
+		targetId
+	});
+};
+var actions$ = {
+	addIndexColumnAction$,
+	removeIndexColumnAction$,
+	changeIndexColumnOrderTypeAction$,
+	moveIndexColumnAction$
+};
+//#endregion
+export { actions$, addIndexColumnAction$, changeIndexColumnOrderTypeAction$, moveIndexColumnAction$, removeIndexColumnAction$ };

package/dist/engine/modules/index-column/history.js

@@ -0,0 +1,55 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ActionType } from "./actions.js";
+import { addIndexColumnAction, changeIndexColumnOrderTypeAction, moveIndexColumnAction, removeIndexColumnAction } from "./atom.actions.js";
+//#region src/engine/modules/index-column/history.ts
+var addIndexColumn = (undoActions, { payload: { id, indexId, tableId } }) => {
+	undoActions.push(removeIndexColumnAction({
+		id,
+		indexId,
+		tableId
+	}));
+};
+var removeIndexColumn = (undoActions, { payload: { id, indexId, tableId } }, { collections }) => {
+	const indexColumn = query(collections).collection("indexColumnEntities").selectById(id);
+	if (!indexColumn) return;
+	undoActions.push(addIndexColumnAction({
+		id,
+		indexId,
+		tableId,
+		columnId: indexColumn.columnId
+	}));
+};
+var moveIndexColumn = (undoActions, { payload: { id, indexId, tableId, targetId } }, { collections }) => {
+	const index = query(collections).collection("indexEntities").selectById(indexId);
+	if (!index) return;
+	const i = index.indexColumnIds.indexOf(id);
+	if (i === -1) return;
+	const targetIndex = index.indexColumnIds.indexOf(targetId);
+	if (targetIndex === -1) return;
+	const revertIndex = i < targetIndex ? i + 1 : i - 1;
+	const newTargetId = index.indexColumnIds[revertIndex];
+	undoActions.push(moveIndexColumnAction({
+		indexId,
+		tableId,
+		id,
+		targetId: newTargetId
+	}));
+};
+var changeIndexColumnOrderType = (undoActions, { payload: { id, indexId, columnId } }, { collections }) => {
+	const indexColumn = query(collections).collection("indexColumnEntities").selectById(id);
+	if (!indexColumn) return;
+	undoActions.push(changeIndexColumnOrderTypeAction({
+		id,
+		indexId,
+		columnId,
+		value: indexColumn.orderType
+	}));
+};
+var indexColumnPushUndoHistoryMap = {
+	[ActionType.addIndexColumn]: addIndexColumn,
+	[ActionType.removeIndexColumn]: removeIndexColumn,
+	[ActionType.moveIndexColumn]: moveIndexColumn,
+	[ActionType.changeIndexColumnOrderType]: changeIndexColumnOrderType
+};
+//#endregion
+export { indexColumnPushUndoHistoryMap };

package/dist/engine/modules/memo/actions.js

@@ -0,0 +1,13 @@
+//#region src/engine/modules/memo/actions.ts
+var ActionType = {
+	addMemo: "memo.add",
+	moveMemo: "memo.move",
+	moveToMemo: "memo.moveTo",
+	removeMemo: "memo.remove",
+	changeMemoValue: "memo.changeValue",
+	changeMemoColor: "memo.changeColor",
+	resizeMemo: "memo.resize",
+	changeZIndex: "memo.changeZIndex"
+};
+//#endregion
+export { ActionType };

package/dist/engine/modules/memo/atom.actions.js

@@ -0,0 +1,106 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { ActionType } from "./actions.js";
+import { createMemo } from "../../../utils/collection/memo.entity.js";
+import { round } from "es-toolkit/compat";
+//#region src/engine/modules/memo/atom.actions.ts
+var addMemoAction = createAction(ActionType.addMemo);
+var addMemo = ({ doc, collections, lww }, { payload: { id, ui }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("memoEntities").addOne(createMemo({
+		id,
+		ui
+	})).addOperator(lww, safeVersion, id, () => {
+		if (!arrayHas(doc.memoIds)(id)) doc.memoIds.push(id);
+	});
+};
+var moveMemoAction = createAction(ActionType.moveMemo);
+var moveMemo = ({ collections }, { payload: { ids, movementX, movementY } }) => {
+	const collection = query(collections).collection("memoEntities");
+	for (const id of ids) collection.getOrCreate(id, (id) => createMemo({ id }));
+	collection.updateMany(ids, (memo) => {
+		memo.ui.x = round(memo.ui.x + movementX, 4);
+		memo.ui.y = round(memo.ui.y + movementY, 4);
+	});
+};
+var moveToMemoAction = createAction(ActionType.moveToMemo);
+var moveToMemo = ({ collections }, { payload: { id, x, y } }) => {
+	const collection = query(collections).collection("memoEntities");
+	collection.getOrCreate(id, (id) => createMemo({ id }));
+	collection.updateOne(id, (memo) => {
+		memo.ui.x = x;
+		memo.ui.y = y;
+	});
+};
+var removeMemoAction = createAction(ActionType.removeMemo);
+var removeMemo = ({ doc, collections, lww }, { payload: { id }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("memoEntities").removeOperator(lww, safeVersion, id, () => {
+		const index = doc.memoIds.indexOf(id);
+		if (index !== -1) doc.memoIds.splice(index, 1);
+	});
+};
+var changeMemoValueAction = createAction(ActionType.changeMemoValue);
+var changeMemoValue = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("memoEntities");
+	collection.getOrCreate(id, (id) => createMemo({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "value", () => {
+		collection.updateOne(id, (memo) => {
+			memo.value = value;
+		});
+	});
+};
+var changeMemoColorAction = createAction(ActionType.changeMemoColor);
+var changeMemoColor = ({ collections, lww }, { payload: { id, color }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("memoEntities");
+	collection.getOrCreate(id, (id) => createMemo({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "ui.color", () => {
+		collection.updateOne(id, (memo) => {
+			memo.ui.color = color;
+		});
+	});
+};
+var resizeMemoAction = createAction(ActionType.resizeMemo);
+var resizeMemo = ({ collections }, { payload: { id, x, y, width, height } }) => {
+	const collection = query(collections).collection("memoEntities");
+	collection.getOrCreate(id, (id) => createMemo({ id }));
+	collection.updateOne(id, (memo) => {
+		memo.ui.x = x;
+		memo.ui.y = y;
+		memo.ui.width = width;
+		memo.ui.height = height;
+	});
+};
+var changeZIndexAction = createAction(ActionType.changeZIndex);
+var changeZIndex = ({ collections }, { payload: { id, zIndex } }) => {
+	const collection = query(collections).collection("memoEntities");
+	collection.getOrCreate(id, (id) => createMemo({ id }));
+	collection.updateOne(id, (memo) => {
+		memo.ui.zIndex = zIndex;
+	});
+};
+var memoReducers = {
+	[ActionType.addMemo]: addMemo,
+	[ActionType.moveMemo]: moveMemo,
+	[ActionType.moveToMemo]: moveToMemo,
+	[ActionType.removeMemo]: removeMemo,
+	[ActionType.changeMemoValue]: changeMemoValue,
+	[ActionType.changeMemoColor]: changeMemoColor,
+	[ActionType.resizeMemo]: resizeMemo,
+	[ActionType.changeZIndex]: changeZIndex
+};
+var actions = {
+	addMemoAction,
+	moveMemoAction,
+	moveToMemoAction,
+	removeMemoAction,
+	changeMemoValueAction,
+	changeMemoColorAction,
+	resizeMemoAction,
+	changeZIndexAction
+};
+//#endregion
+export { actions, addMemoAction, changeMemoColorAction, changeMemoValueAction, changeZIndexAction, memoReducers, moveMemoAction, moveToMemoAction, removeMemoAction, resizeMemoAction };

package/dist/engine/modules/memo/generator.actions.js

@@ -0,0 +1,50 @@
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { SelectType } from "../editor/state.js";
+import { nextPoint, nextZIndex } from "../../../utils/index.js";
+import { selectAction } from "../editor/atom.actions.js";
+import { addMemoAction, changeZIndexAction, removeMemoAction } from "./atom.actions.js";
+import { unselectAllAction$ } from "../editor/generator.actions.js";
+//#region src/engine/modules/memo/generator.actions.ts
+var addMemoAction$ = () => function* ({ settings, doc: { tableIds, memoIds }, collections }) {
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds);
+	const memos = query(collections).collection("memoEntities").selectByIds(memoIds);
+	const point = nextPoint(settings, tables, memos);
+	const id = uuid25();
+	yield unselectAllAction$();
+	yield addMemoAction({
+		id,
+		ui: {
+			...point,
+			zIndex: nextZIndex(tables, memos)
+		}
+	});
+	yield selectAction({ [id]: SelectType.memo });
+};
+var removeMemoAction$ = (id) => function* ({ doc: { memoIds }, editor: { selectedMap } }) {
+	if (id) {
+		yield removeMemoAction({ id });
+		return;
+	}
+	const isInDoc = arrayHas(memoIds);
+	const selectedMemos = Object.entries(selectedMap).filter(([id, type]) => type === SelectType.memo && isInDoc(id));
+	for (const [id] of selectedMemos) yield removeMemoAction({ id });
+};
+var selectMemoAction$ = (id, $mod) => function* ({ doc: { tableIds, memoIds }, collections }) {
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds);
+	const memos = query(collections).collection("memoEntities").selectByIds(memoIds);
+	if (!$mod) yield unselectAllAction$();
+	yield selectAction({ [id]: SelectType.memo });
+	yield changeZIndexAction({
+		id,
+		zIndex: nextZIndex(tables, memos)
+	});
+};
+var actions$ = {
+	addMemoAction$,
+	removeMemoAction$,
+	selectMemoAction$
+};
+//#endregion
+export { actions$, addMemoAction$, removeMemoAction$, selectMemoAction$ };

package/dist/engine/modules/memo/history.js

@@ -0,0 +1,109 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ActionType } from "./actions.js";
+import { addMemoAction, changeMemoColorAction, changeMemoValueAction, moveMemoAction, moveToMemoAction, removeMemoAction, resizeMemoAction } from "./atom.actions.js";
+import { groupBy, head, last, pick } from "es-toolkit";
+//#region src/engine/modules/memo/history.ts
+var MOVE_MIN = 20;
+var addMemo = (undoActions, { payload: { id } }) => {
+	undoActions.push(removeMemoAction({ id }));
+};
+var removeMemo = (undoActions, { payload: { id } }, { collections }) => {
+	const memo = query(collections).collection("memoEntities").selectById(id);
+	if (!memo) return;
+	undoActions.push(addMemoAction({
+		id: memo.id,
+		ui: pick(memo.ui, [
+			"x",
+			"y",
+			"zIndex"
+		])
+	}));
+};
+var changeMemoValue = (undoActions, { payload: { id } }, { collections }) => {
+	const memo = query(collections).collection("memoEntities").selectById(id);
+	if (!memo) return;
+	undoActions.push(changeMemoValueAction({
+		id,
+		value: memo.value
+	}));
+};
+var moveToMemo = (undoActions, { payload: { id } }, { collections }) => {
+	const memo = query(collections).collection("memoEntities").selectById(id);
+	if (!memo) return;
+	undoActions.push(moveToMemoAction({
+		id,
+		x: memo.ui.x,
+		y: memo.ui.y
+	}));
+};
+var memoPushUndoHistoryMap = {
+	[ActionType.addMemo]: addMemo,
+	[ActionType.removeMemo]: removeMemo,
+	[ActionType.changeMemoValue]: changeMemoValue,
+	[ActionType.moveToMemo]: moveToMemo
+};
+var moveMemo = (undoActions, redoActions, actions) => {
+	const moveMemoActions = actions.filter((action) => action.type === moveMemoAction.type);
+	if (!moveMemoActions.length) return;
+	const group = groupBy(moveMemoActions, (action) => action.payload.ids.join(","));
+	for (const [, actions] of Object.entries(group)) {
+		const { payload: { ids } } = head(actions);
+		const { x, y } = actions.reduce((acc, { payload: { movementX, movementY } }) => {
+			acc.x += movementX;
+			acc.y += movementY;
+			return acc;
+		}, {
+			x: 0,
+			y: 0
+		});
+		if (Math.abs(x) + Math.abs(y) < MOVE_MIN) continue;
+		undoActions.push(moveMemoAction({
+			ids,
+			movementX: -1 * x,
+			movementY: -1 * y
+		}));
+		redoActions.push(moveMemoAction({
+			ids,
+			movementX: x,
+			movementY: y
+		}));
+	}
+};
+var changeMemoColor = (undoActions, redoActions, actions) => {
+	const changeMemoColorActions = actions.filter(({ type }) => type === changeMemoColorAction.type);
+	if (!changeMemoColorActions.length) return;
+	const group = groupBy(changeMemoColorActions, (action) => action.payload.id);
+	for (const [id, actions] of Object.entries(group)) {
+		const firstAction = head(actions);
+		const lastAction = last(actions);
+		undoActions.push(changeMemoColorAction({
+			id,
+			color: firstAction.payload.prevColor,
+			prevColor: lastAction.payload.color
+		}));
+		redoActions.push(changeMemoColorAction({
+			id,
+			color: lastAction.payload.color,
+			prevColor: firstAction.payload.prevColor
+		}));
+	}
+};
+var resizeMemo = (undoActions, redoActions, actions) => {
+	const resizeMemoActions = actions.filter((action) => action.type === resizeMemoAction.type);
+	if (!resizeMemoActions.length) return;
+	const group = groupBy(resizeMemoActions, (action) => action.payload.id);
+	for (const [, actions] of Object.entries(group)) {
+		if (actions.length < 2) continue;
+		const firstAction = head(actions);
+		const lastAction = last(actions);
+		undoActions.push(firstAction);
+		redoActions.push(lastAction);
+	}
+};
+var memoPushStreamHistoryMap = {
+	[ActionType.moveMemo]: moveMemo,
+	[ActionType.changeMemoColor]: changeMemoColor,
+	[ActionType.resizeMemo]: resizeMemo
+};
+//#endregion
+export { memoPushStreamHistoryMap, memoPushUndoHistoryMap };

package/dist/engine/modules/relationship/actions.js

@@ -0,0 +1,11 @@
+//#region src/engine/modules/relationship/actions.ts
+var ActionType = {
+	addRelationship: "relationship.add",
+	removeRelationship: "relationship.remove",
+	changeRelationshipType: "relationship.changeType",
+	changeRelationshipOnDelete: "relationship.changeOnDelete",
+	changeRelationshipOnUpdate: "relationship.changeOnUpdate",
+	changeRelationshipColumns: "relationship.changeColumns"
+};
+//#endregion
+export { ActionType };