@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,146 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../../constants/schema.js";
+import { ActionType } from "./actions.js";
+import { addColumnAction, changeColumnAutoIncrementAction, changeColumnCommentAction, changeColumnDataTypeAction, changeColumnDefaultAction, changeColumnDomainAction, changeColumnLogicalNameAction, changeColumnNameAction, changeColumnNameDerivedAction, changeColumnNotNullAction, changeColumnPrimaryKeyAction, changeColumnUniqueAction, moveColumnAction, removeColumnAction } from "./atom.actions.js";
+import { bHas } from "../../../utils/bit.js";
+//#region src/engine/modules/table-column/history.ts
+var addColumn = (undoActions, { payload: { id, tableId } }) => {
+	undoActions.push(removeColumnAction({
+		id,
+		tableId
+	}));
+};
+var removeColumn = (undoActions, { payload: { id, tableId } }) => {
+	undoActions.push(addColumnAction({
+		id,
+		tableId
+	}));
+};
+var changeColumnName = (undoActions, { payload: { id, tableId } }, { collections }) => {
+	const column = query(collections).collection("tableColumnEntities").selectById(id);
+	if (!column) return;
+	undoActions.push(changeColumnNameAction({
+		id,
+		tableId,
+		value: column.name
+	}));
+};
+var changeColumnDataType = (undoActions, { payload: { id, tableId } }, { collections }) => {
+	const column = query(collections).collection("tableColumnEntities").selectById(id);
+	if (!column) return;
+	undoActions.push(changeColumnDataTypeAction({
+		id,
+		tableId,
+		value: column.dataType
+	}));
+};
+var changeColumnDefault = (undoActions, { payload: { id, tableId } }, { collections }) => {
+	const column = query(collections).collection("tableColumnEntities").selectById(id);
+	if (!column) return;
+	undoActions.push(changeColumnDefaultAction({
+		id,
+		tableId,
+		value: column.default
+	}));
+};
+var changeComment = (undoActions, { payload: { id, tableId } }, { collections }) => {
+	const column = query(collections).collection("tableColumnEntities").selectById(id);
+	if (!column) return;
+	undoActions.push(changeColumnCommentAction({
+		id,
+		tableId,
+		value: column.comment
+	}));
+};
+var changeColumnAutoIncrement = (undoActions, { payload: { id, tableId, value } }, { collections }) => {
+	if (!query(collections).collection("tableColumnEntities").selectById(id)) return;
+	undoActions.push(changeColumnAutoIncrementAction({
+		id,
+		tableId,
+		value: !value
+	}));
+};
+var changeColumnNotNull = (undoActions, { payload: { id, tableId, value } }, { collections }) => {
+	if (!query(collections).collection("tableColumnEntities").selectById(id)) return;
+	undoActions.push(changeColumnNotNullAction({
+		id,
+		tableId,
+		value: !value
+	}));
+};
+var changeColumnPrimaryKey = (undoActions, { payload: { id, tableId, value } }, { collections }) => {
+	if (!query(collections).collection("tableColumnEntities").selectById(id)) return;
+	undoActions.push(changeColumnPrimaryKeyAction({
+		id,
+		tableId,
+		value: !value
+	}));
+};
+var changeColumnUnique = (undoActions, { payload: { id, tableId, value } }, { collections }) => {
+	if (!query(collections).collection("tableColumnEntities").selectById(id)) return;
+	undoActions.push(changeColumnUniqueAction({
+		id,
+		tableId,
+		value: !value
+	}));
+};
+var changeColumnLogicalName = (undoActions, { payload: { id, tableId } }, { collections }) => {
+	const column = query(collections).collection("tableColumnEntities").selectById(id);
+	if (!column) return;
+	undoActions.push(changeColumnLogicalNameAction({
+		id,
+		tableId,
+		value: column.logicalName
+	}));
+};
+var changeColumnDomain = (undoActions, { payload: { id, tableId } }, { collections }) => {
+	const column = query(collections).collection("tableColumnEntities").selectById(id);
+	if (!column) return;
+	undoActions.push(changeColumnDomainAction({
+		id,
+		tableId,
+		value: column.domainId
+	}));
+};
+var changeColumnNameDerived = (undoActions, { payload: { id, tableId } }, { collections }) => {
+	const column = query(collections).collection("tableColumnEntities").selectById(id);
+	if (!column) return;
+	undoActions.push(changeColumnNameDerivedAction({
+		id,
+		tableId,
+		value: bHas(column.options, ColumnOption.nameDerived)
+	}));
+};
+var moveColumn = (undoActions, { payload: { id, tableId, targetId } }, { collections }) => {
+	const table = query(collections).collection("tableEntities").selectById(tableId);
+	if (!table) return;
+	const index = table.columnIds.indexOf(id);
+	if (index === -1) return;
+	const targetIndex = table.columnIds.indexOf(targetId);
+	if (targetIndex === -1) return;
+	const revertIndex = index < targetIndex ? index + 1 : index - 1;
+	const newTargetId = table.columnIds[revertIndex];
+	undoActions.push(moveColumnAction({
+		id,
+		tableId,
+		targetId: newTargetId
+	}));
+};
+var tableColumnPushUndoHistoryMap = {
+	[ActionType.addColumn]: addColumn,
+	[ActionType.removeColumn]: removeColumn,
+	[ActionType.changeColumnName]: changeColumnName,
+	[ActionType.changeColumnDataType]: changeColumnDataType,
+	[ActionType.changeColumnDefault]: changeColumnDefault,
+	[ActionType.changeColumnComment]: changeComment,
+	[ActionType.changeColumnAutoIncrement]: changeColumnAutoIncrement,
+	[ActionType.changeColumnNotNull]: changeColumnNotNull,
+	[ActionType.changeColumnPrimaryKey]: changeColumnPrimaryKey,
+	[ActionType.changeColumnUnique]: changeColumnUnique,
+	[ActionType.moveColumn]: moveColumn,
+	[ActionType.changeColumnLogicalName]: changeColumnLogicalName,
+	[ActionType.changeColumnDomain]: changeColumnDomain,
+	[ActionType.changeColumnNameDerived]: changeColumnNameDerived
+};
+//#endregion
+export { tableColumnPushUndoHistoryMap };

package/dist/engine/modules/table-column/hooks.js

@@ -0,0 +1,33 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../../constants/schema.js";
+import { addColumnAction, changeColumnPrimaryKeyAction, removeColumnAction } from "./atom.actions.js";
+import { bHas } from "../../../utils/bit.js";
+import { validateForeignKeys } from "./keys.js";
+import { addRelationshipAction, changeRelationshipColumnsAction, removeRelationshipAction } from "../relationship/atom.actions.js";
+import { addTableAction, removeTableAction } from "../table/atom.actions.js";
+import { asapScheduler, observeOn, throttle, timer } from "rxjs";
+//#region src/engine/modules/table-column/hooks.ts
+var deferred = (action$) => action$.pipe(observeOn(asapScheduler));
+var changeColumnNotNullHook = (action$, getState) => deferred(action$).subscribe(({ payload: { id } }) => {
+	const { collections } = getState();
+	const column = query(collections).collection("tableColumnEntities").selectById(id);
+	if (!column) return;
+	if (!bHas(column.options, ColumnOption.primaryKey)) return;
+	if (bHas(column.options, ColumnOption.notNull)) return;
+	column.options = column.options | ColumnOption.notNull;
+});
+var validationForeignKeyHook = (action$, getState) => action$.pipe(throttle(() => timer(0, asapScheduler), {
+	leading: false,
+	trailing: true
+})).subscribe(() => validateForeignKeys(getState()));
+var hooks = [[[changeColumnPrimaryKeyAction], changeColumnNotNullHook], [[
+	addRelationshipAction,
+	removeRelationshipAction,
+	changeRelationshipColumnsAction,
+	addColumnAction,
+	removeColumnAction,
+	addTableAction,
+	removeTableAction
+], validationForeignKeyHook]];
+//#endregion
+export { hooks };

package/dist/engine/modules/table-column/keys.js

@@ -0,0 +1,30 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, ColumnUIKey } from "../../../constants/schema.js";
+import { bHas } from "../../../utils/bit.js";
+//#region src/engine/modules/table-column/keys.ts
+function syncPrimaryKeys({ collections }) {
+	for (const column of query(collections).collection("tableColumnEntities").selectAll()) {
+		const value = bHas(column.options, ColumnOption.primaryKey);
+		if (value === bHas(column.ui.keys, ColumnUIKey.primaryKey)) continue;
+		column.ui.keys = value ? column.ui.keys | ColumnUIKey.primaryKey : column.ui.keys & ~ColumnUIKey.primaryKey;
+	}
+}
+function validateForeignKeys({ doc, collections }) {
+	const endColumnIds = /* @__PURE__ */ new Map();
+	const relationships = query(collections).collection("relationshipEntities").selectByIds(doc.relationshipIds);
+	for (const { end } of relationships) {
+		const ids = endColumnIds.get(end.tableId) ?? /* @__PURE__ */ new Set();
+		end.columnIds.forEach((id) => ids.add(id));
+		endColumnIds.set(end.tableId, ids);
+	}
+	const tableIdOf = /* @__PURE__ */ new Map();
+	for (const table of query(collections).collection("tableEntities").selectByIds(doc.tableIds)) table.columnIds.forEach((id) => tableIdOf.set(id, table.id));
+	for (const column of query(collections).collection("tableColumnEntities").selectAll()) {
+		const tableId = tableIdOf.get(column.id);
+		const value = tableId !== void 0 && (endColumnIds.get(tableId)?.has(column.id) ?? false);
+		if (value === bHas(column.ui.keys, ColumnUIKey.foreignKey)) continue;
+		column.ui.keys = value ? column.ui.keys | ColumnUIKey.foreignKey : column.ui.keys & ~ColumnUIKey.foreignKey;
+	}
+}
+//#endregion
+export { syncPrimaryKeys, validateForeignKeys };

package/dist/engine/modules/table-column/utils/dataType.js

@@ -0,0 +1,71 @@
+import { query } from "../../../../erd-editor-schema/dist/query/index.js";
+import { isSerialType, toReferenceDataType } from "../../relationship/referenceType.js";
+//#region src/engine/modules/table-column/utils/dataType.ts
+function toSyncSteps(relationships) {
+	const steps = /* @__PURE__ */ new Map();
+	const add = (from, step) => {
+		const list = steps.get(from);
+		if (list) list.push(step);
+		else steps.set(from, [step]);
+	};
+	for (const { start, end } of relationships) {
+		const startIds = [...start.columnIds];
+		const endIds = [...end.columnIds];
+		const seen = /* @__PURE__ */ new Set();
+		startIds.forEach((from, index) => {
+			if (seen.has(from)) return;
+			seen.add(from);
+			const id = endIds[index];
+			if (id !== void 0) add(from, {
+				id,
+				tableId: end.tableId,
+				toForeignKey: true
+			});
+		});
+		endIds.forEach((from, index) => {
+			if (seen.has(from)) return;
+			seen.add(from);
+			const id = startIds[index];
+			if (id !== void 0) add(from, {
+				id,
+				tableId: start.tableId,
+				toForeignKey: false
+			});
+		});
+	}
+	return steps;
+}
+function getDataTypeSyncColumns(stack, state, payloads = [], relationships = query(state.collections).collection("relationshipEntities").selectByIds(state.doc.relationshipIds), settledIds = /* @__PURE__ */ new Set()) {
+	const { collections, settings: { database } } = state;
+	const columns = query(collections).collection("tableColumnEntities");
+	const steps = toSyncSteps(relationships);
+	const listed = new Set(payloads.map(({ id }) => id));
+	for (let target = stack.pop(); target; target = stack.pop()) {
+		const { id: targetId, value } = target;
+		if (listed.has(targetId)) continue;
+		payloads.push(target);
+		listed.add(targetId);
+		const foreignKeyValue = toReferenceDataType(value, database);
+		for (const { id, tableId, toForeignKey } of steps.get(targetId) ?? []) {
+			if (settledIds.has(id)) continue;
+			if (toForeignKey) {
+				stack.push({
+					id,
+					tableId,
+					value: foreignKeyValue
+				});
+				continue;
+			}
+			const column = columns.selectById(id);
+			if (column && isSerialType(column.dataType)) continue;
+			stack.push({
+				id,
+				tableId,
+				value
+			});
+		}
+	}
+	return payloads;
+}
+//#endregion
+export { getDataTypeSyncColumns };

package/dist/engine/modules/table-group/actions.js

@@ -0,0 +1,13 @@
+//#region src/engine/modules/table-group/actions.ts
+var ActionType = {
+	addTableGroup: "tableGroup.add",
+	moveTableGroup: "tableGroup.move",
+	moveToTableGroup: "tableGroup.moveTo",
+	removeTableGroup: "tableGroup.remove",
+	resizeTableGroup: "tableGroup.resize",
+	changeTableGroupName: "tableGroup.changeName",
+	changeTableGroupColor: "tableGroup.changeColor",
+	changeTableGroupZIndex: "tableGroup.changeZIndex"
+};
+//#endregion
+export { ActionType };

package/dist/engine/modules/table-group/atom.actions.js

@@ -0,0 +1,108 @@
+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 { createTableGroup } from "../../../utils/collection/tableGroup.entity.js";
+import { isString } from "es-toolkit";
+import { round } from "es-toolkit/compat";
+//#region src/engine/modules/table-group/atom.actions.ts
+var addTableGroupAction = createAction(ActionType.addTableGroup);
+var addTableGroup = ({ doc, collections, lww }, { payload: { id, color, ui }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("tableGroupEntities").addOne(createTableGroup({
+		id,
+		ui,
+		...isString(color) ? { color } : {}
+	})).addOperator(lww, safeVersion, id, () => {
+		if (!arrayHas(doc.tableGroupIds)(id)) doc.tableGroupIds.push(id);
+	});
+};
+var moveTableGroupAction = createAction(ActionType.moveTableGroup);
+var moveTableGroup = ({ collections }, { payload: { ids, movementX, movementY } }) => {
+	const collection = query(collections).collection("tableGroupEntities");
+	for (const id of ids) collection.getOrCreate(id, (id) => createTableGroup({ id }));
+	collection.updateMany(ids, (group) => {
+		group.ui.x = round(group.ui.x + movementX, 4);
+		group.ui.y = round(group.ui.y + movementY, 4);
+	});
+};
+var moveToTableGroupAction = createAction(ActionType.moveToTableGroup);
+var moveToTableGroup = ({ collections }, { payload: { id, x, y } }) => {
+	const collection = query(collections).collection("tableGroupEntities");
+	collection.getOrCreate(id, (id) => createTableGroup({ id }));
+	collection.updateOne(id, (group) => {
+		group.ui.x = x;
+		group.ui.y = y;
+	});
+};
+var removeTableGroupAction = createAction(ActionType.removeTableGroup);
+var removeTableGroup = ({ doc, collections, lww }, { payload: { id }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("tableGroupEntities").removeOperator(lww, safeVersion, id, () => {
+		const index = doc.tableGroupIds.indexOf(id);
+		if (index !== -1) doc.tableGroupIds.splice(index, 1);
+	});
+};
+var resizeTableGroupAction = createAction(ActionType.resizeTableGroup);
+var resizeTableGroup = ({ collections }, { payload: { id, x, y, width, height } }) => {
+	const collection = query(collections).collection("tableGroupEntities");
+	collection.getOrCreate(id, (id) => createTableGroup({ id }));
+	collection.updateOne(id, (group) => {
+		group.ui.x = x;
+		group.ui.y = y;
+		group.ui.width = width;
+		group.ui.height = height;
+	});
+};
+var changeTableGroupNameAction = createAction(ActionType.changeTableGroupName);
+var changeTableGroupName = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableGroupEntities");
+	collection.getOrCreate(id, (id) => createTableGroup({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "name", () => {
+		collection.updateOne(id, (group) => {
+			group.name = value;
+		});
+	});
+};
+var changeTableGroupColorAction = createAction(ActionType.changeTableGroupColor);
+var changeTableGroupColor = ({ collections, lww }, { payload: { id, color }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableGroupEntities");
+	collection.getOrCreate(id, (id) => createTableGroup({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "color", () => {
+		collection.updateOne(id, (group) => {
+			group.color = color;
+		});
+	});
+};
+var changeTableGroupZIndexAction = createAction(ActionType.changeTableGroupZIndex);
+var changeTableGroupZIndex = ({ collections }, { payload: { id, zIndex } }) => {
+	const collection = query(collections).collection("tableGroupEntities");
+	collection.getOrCreate(id, (id) => createTableGroup({ id }));
+	collection.updateOne(id, (group) => {
+		group.ui.zIndex = zIndex;
+	});
+};
+var tableGroupReducers = {
+	[ActionType.addTableGroup]: addTableGroup,
+	[ActionType.moveTableGroup]: moveTableGroup,
+	[ActionType.moveToTableGroup]: moveToTableGroup,
+	[ActionType.removeTableGroup]: removeTableGroup,
+	[ActionType.resizeTableGroup]: resizeTableGroup,
+	[ActionType.changeTableGroupName]: changeTableGroupName,
+	[ActionType.changeTableGroupColor]: changeTableGroupColor,
+	[ActionType.changeTableGroupZIndex]: changeTableGroupZIndex
+};
+var actions = {
+	addTableGroupAction,
+	moveTableGroupAction,
+	moveToTableGroupAction,
+	removeTableGroupAction,
+	resizeTableGroupAction,
+	changeTableGroupNameAction,
+	changeTableGroupColorAction,
+	changeTableGroupZIndexAction
+};
+//#endregion
+export { actions, addTableGroupAction, changeTableGroupColorAction, changeTableGroupNameAction, changeTableGroupZIndexAction, moveTableGroupAction, moveToTableGroupAction, removeTableGroupAction, resizeTableGroupAction, tableGroupReducers };

package/dist/engine/modules/table-group/generator.actions.js

@@ -0,0 +1,158 @@
+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 { Tag, attachActionTag } from "../../tag.js";
+import { unionRect } from "../../../konva/scene/metrics.js";
+import { findTableGroupsAt, getTableCenter, getTableGroupId, getTableGroupMemberIds, getTableGroupRects, getTablesGroupRect, isPointInRect, isTableGroupShown, nextTableGroupZIndex } from "../../../utils/tableGroup.js";
+import { selectAction } from "../editor/atom.actions.js";
+import { changeTableGroupAction, changeZIndexAction, moveTableAction } from "../table/atom.actions.js";
+import { addTableGroupAction, changeTableGroupNameAction, changeTableGroupZIndexAction, moveTableGroupAction, removeTableGroupAction } from "./atom.actions.js";
+import { getSelectTypeIds } from "../editor/utils/selection.js";
+import { unselectAllAction$ } from "../editor/generator.actions.js";
+import { uniq } from "es-toolkit";
+//#region src/engine/modules/table-group/generator.actions.ts
+var selectGroups = ({ doc, collections }) => query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds);
+function* addGroup$(state, rect, tableIds, { name, color }) {
+	const id = uuid25();
+	const { x, y, width, height } = rect;
+	yield unselectAllAction$();
+	yield addTableGroupAction({
+		id,
+		...color ? { color } : {},
+		ui: {
+			x,
+			y,
+			width,
+			height,
+			zIndex: nextTableGroupZIndex(selectGroups(state))
+		}
+	});
+	yield selectAction({ [id]: SelectType.tableGroup });
+	if (name) yield changeTableGroupNameAction({
+		id,
+		value: name
+	});
+	yield tableIds.map((tableId) => changeTableGroupAction({
+		id: tableId,
+		value: id
+	}));
+}
+var addTableGroupAction$ = (rect, fields = {}) => function* (state) {
+	const { doc, collections } = state;
+	yield* addGroup$(state, rect, query(collections).collection("tableEntities").selectByIds(doc.tableIds).filter((table) => !getTableGroupId(state, table) && isPointInRect(getTableCenter(state, table), rect)).map(({ id }) => id), fields);
+};
+var addTableGroupFromTablesAction$ = (tableIds, fields = {}) => function* (state) {
+	const ids = uniq(tableIds ?? getSelectTypeIds(state.editor.selectedMap).tableIds).filter(arrayHas(state.doc.tableIds));
+	const rect = getTablesGroupRect(state, ids);
+	if (!rect) return;
+	yield* addGroup$(state, rect, ids, fields);
+};
+var removeTableGroupAction$ = (id) => function* (state) {
+	const { doc: { tableGroupIds }, editor: { selectedMap } } = state;
+	const isInDoc = arrayHas(tableGroupIds);
+	const ids = id ? [id] : Object.entries(selectedMap).filter(([id, type]) => type === SelectType.tableGroup && isInDoc(id)).map(([id]) => id);
+	for (const groupId of ids) {
+		yield getTableGroupMemberIds(state, groupId).map((tableId) => changeTableGroupAction({
+			id: tableId,
+			value: ""
+		}));
+		yield removeTableGroupAction({ id: groupId });
+	}
+};
+function getCarriedTableIds(state, groupIds, tableIds) {
+	return uniq([...tableIds, ...groupIds.flatMap((id) => getTableGroupMemberIds(state, id))]);
+}
+function toMoveTableGroupActions(groupIds, tableIds, movementX, movementY) {
+	return [...groupIds.length ? [moveTableGroupAction({
+		ids: groupIds,
+		movementX,
+		movementY
+	})] : [], ...tableIds.length ? [moveTableAction({
+		ids: tableIds,
+		movementX,
+		movementY
+	})] : []].map((action) => attachActionTag(Tag.drag, action));
+}
+var moveTableGroupAction$ = (ids, movementX, movementY) => function* (state) {
+	yield toMoveTableGroupActions(ids, getCarriedTableIds(state, ids, []), movementX, movementY);
+};
+var setTableGroupAction$ = (tableIds, groupId) => function* ({ doc, collections }) {
+	if (groupId && !doc.tableGroupIds.includes(groupId)) return;
+	yield query(collections).collection("tableEntities").selectByIds(uniq(tableIds).filter(arrayHas(doc.tableIds))).filter((table) => table.groupId !== groupId).map(({ id }) => changeTableGroupAction({
+		id,
+		value: groupId
+	}));
+};
+function getTableGroupDrops(state, held) {
+	if (!isTableGroupShown(state)) return [];
+	const { doc, collections, editor } = state;
+	const { tableIds, tableGroupIds } = getSelectTypeIds(editor.selectedMap);
+	const listed = new Set(doc.tableIds);
+	const selected = tableIds.filter((id) => listed.has(id));
+	if (!selected.length) return [];
+	const carried = new Set(tableGroupIds.flatMap((id) => getTableGroupMemberIds(state, id)));
+	const judged = selected.filter((id) => !carried.has(id));
+	if (!judged.length) return [];
+	const moving = new Set(tableGroupIds);
+	const boxes = getTableGroupRects(state, { excludeTableIds: judged });
+	held?.forEach((rect, id) => {
+		const box = boxes.get(id);
+		if (box && !moving.has(id)) boxes.set(id, unionRect(box, rect));
+	});
+	const tables = query(collections).collection("tableEntities").selectByIds(judged);
+	const groups = findTableGroupsAt(state, tables.map((table) => getTableCenter(state, table)), { boxes });
+	return tables.map((table, index) => {
+		const groupId = groups[index]?.id ?? "";
+		return {
+			table,
+			groupId,
+			box: boxes.get(groupId) ?? null
+		};
+	});
+}
+var dropTablesIntoGroupsAction$ = (held) => function* (state) {
+	yield getTableGroupDrops(state, held).filter(({ table, groupId }) => groupId !== getTableGroupId(state, table)).map(({ table, groupId }) => attachActionTag(Tag.drag, changeTableGroupAction({
+		id: table.id,
+		value: groupId,
+		prevValue: table.groupId
+	})));
+};
+var selectTableGroupAction$ = (id, $mod) => function* (state) {
+	if (!$mod) yield unselectAllAction$();
+	yield selectAction({ [id]: SelectType.tableGroup });
+	yield changeTableGroupZIndexAction({
+		id,
+		zIndex: nextTableGroupZIndex(selectGroups(state))
+	});
+	yield raiseMembers(state, id);
+};
+function raiseMembers(state, groupId) {
+	const { doc: { tableIds, memoIds }, collections } = state;
+	const isMember = arrayHas(getTableGroupMemberIds(state, groupId));
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds);
+	const members = tables.filter((table) => isMember(table.id)).sort((a, b) => a.ui.zIndex - b.ui.zIndex);
+	const others = [...tables.filter((table) => !isMember(table.id)), ...query(collections).collection("memoEntities").selectByIds(memoIds)];
+	const base = Math.max(1, ...others.map(({ ui }) => ui.zIndex)) + 1;
+	if (members.every(({ ui }) => ui.zIndex >= base)) return [];
+	return members.map((table, index) => changeZIndexAction({
+		id: table.id,
+		zIndex: base + index
+	}));
+}
+var selectTableGroupTablesAction$ = (id) => function* (state) {
+	yield unselectAllAction$();
+	yield selectAction(Object.fromEntries(getTableGroupMemberIds(state, id).map((tableId) => [tableId, SelectType.table])));
+};
+var actions$ = {
+	addTableGroupAction$,
+	addTableGroupFromTablesAction$,
+	removeTableGroupAction$,
+	moveTableGroupAction$,
+	setTableGroupAction$,
+	dropTablesIntoGroupsAction$,
+	selectTableGroupAction$,
+	selectTableGroupTablesAction$
+};
+//#endregion
+export { actions$, addTableGroupAction$, addTableGroupFromTablesAction$, dropTablesIntoGroupsAction$, getCarriedTableIds, getTableGroupDrops, moveTableGroupAction$, removeTableGroupAction$, selectTableGroupAction$, selectTableGroupTablesAction$, setTableGroupAction$, toMoveTableGroupActions };

package/dist/engine/modules/table-group/history.js

@@ -0,0 +1,106 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ActionType } from "./actions.js";
+import { addTableGroupAction, changeTableGroupColorAction, changeTableGroupNameAction, moveTableGroupAction, moveToTableGroupAction, removeTableGroupAction, resizeTableGroupAction } from "./atom.actions.js";
+import { groupBy, head, last } from "es-toolkit";
+//#region src/engine/modules/table-group/history.ts
+var MOVE_MIN = 20;
+var addTableGroup = (undoActions, { payload: { id } }) => {
+	undoActions.push(removeTableGroupAction({ id }));
+};
+var removeTableGroup = (undoActions, { payload: { id } }, { collections }) => {
+	const group = query(collections).collection("tableGroupEntities").selectById(id);
+	if (!group) return;
+	undoActions.push(addTableGroupAction({
+		id: group.id,
+		color: group.color,
+		ui: { ...group.ui }
+	}));
+};
+var changeTableGroupName = (undoActions, { payload: { id } }, { collections }) => {
+	const group = query(collections).collection("tableGroupEntities").selectById(id);
+	if (!group) return;
+	undoActions.push(changeTableGroupNameAction({
+		id,
+		value: group.name
+	}));
+};
+var moveToTableGroup = (undoActions, { payload: { id } }, { collections }) => {
+	const group = query(collections).collection("tableGroupEntities").selectById(id);
+	if (!group) return;
+	undoActions.push(moveToTableGroupAction({
+		id,
+		x: group.ui.x,
+		y: group.ui.y
+	}));
+};
+var resizeTableGroup = (undoActions, { payload: { id } }, { collections }) => {
+	const group = query(collections).collection("tableGroupEntities").selectById(id);
+	if (!group) return;
+	const { x, y, width, height } = group.ui;
+	undoActions.push(resizeTableGroupAction({
+		id,
+		x,
+		y,
+		width,
+		height
+	}));
+};
+var tableGroupPushUndoHistoryMap = {
+	[ActionType.addTableGroup]: addTableGroup,
+	[ActionType.removeTableGroup]: removeTableGroup,
+	[ActionType.changeTableGroupName]: changeTableGroupName,
+	[ActionType.moveToTableGroup]: moveToTableGroup,
+	[ActionType.resizeTableGroup]: resizeTableGroup
+};
+var moveTableGroup = (undoActions, redoActions, actions) => {
+	const moveActions = actions.filter((action) => action.type === moveTableGroupAction.type);
+	if (!moveActions.length) return;
+	const group = groupBy(moveActions, (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(moveTableGroupAction({
+			ids,
+			movementX: -1 * x,
+			movementY: -1 * y
+		}));
+		redoActions.push(moveTableGroupAction({
+			ids,
+			movementX: x,
+			movementY: y
+		}));
+	}
+};
+var changeTableGroupColor = (undoActions, redoActions, actions) => {
+	const colorActions = actions.filter(({ type }) => type === changeTableGroupColorAction.type);
+	if (!colorActions.length) return;
+	const group = groupBy(colorActions, (action) => action.payload.id);
+	for (const [id, actions] of Object.entries(group)) {
+		const firstAction = head(actions);
+		const lastAction = last(actions);
+		undoActions.push(changeTableGroupColorAction({
+			id,
+			color: firstAction.payload.prevColor,
+			prevColor: lastAction.payload.color
+		}));
+		redoActions.push(changeTableGroupColorAction({
+			id,
+			color: lastAction.payload.color,
+			prevColor: firstAction.payload.prevColor
+		}));
+	}
+};
+var tableGroupPushStreamHistoryMap = {
+	[ActionType.moveTableGroup]: moveTableGroup,
+	[ActionType.changeTableGroupColor]: changeTableGroupColor
+};
+//#endregion
+export { tableGroupPushStreamHistoryMap, tableGroupPushUndoHistoryMap };