@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,17 @@
+//#region src/engine/modules/table/actions.ts
+var ActionType = {
+	addTable: "table.add",
+	moveTable: "table.move",
+	moveToTable: "table.moveTo",
+	removeTable: "table.remove",
+	changeTableName: "table.changeName",
+	changeTableComment: "table.changeComment",
+	changeTableColor: "table.changeColor",
+	changeTableGroup: "table.changeGroup",
+	changeZIndex: "table.changeZIndex",
+	sortTable: "table.sort",
+	changeTableLogicalName: "table.changeLogicalName",
+	changeTableNameDerived: "table.changeNameDerived"
+};
+//#endregion
+export { ActionType };

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

@@ -0,0 +1,231 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { canvasSizeInRange, textInRange } from "../../../utils/validation.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { createTable } from "../../../utils/collection/table.entity.js";
+import { calcTableHeight, calcTableWidths } from "../../../utils/calcTable.js";
+import { unionRect } from "../../../konva/scene/metrics.js";
+import { getTableGroupId, padRect } from "../../../utils/tableGroup.js";
+import { ActionType } from "./actions.js";
+import { round } from "es-toolkit/compat";
+//#region src/engine/modules/table/atom.actions.ts
+var addTableAction = createAction(ActionType.addTable);
+var addTable = ({ doc, collections, lww }, { payload: { id, ui }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("tableEntities").addOne(createTable({
+		id,
+		ui
+	})).addOperator(lww, safeVersion, id, () => {
+		if (!arrayHas(doc.tableIds)(id)) doc.tableIds.push(id);
+	});
+};
+var moveTableAction = createAction(ActionType.moveTable);
+var moveTable = ({ collections }, { payload: { ids, movementX, movementY } }) => {
+	const collection = query(collections).collection("tableEntities");
+	for (const id of ids) collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.updateMany(ids, (table) => {
+		table.ui.x = round(table.ui.x + movementX, 4);
+		table.ui.y = round(table.ui.y + movementY, 4);
+	});
+};
+var moveToTableAction = createAction(ActionType.moveToTable);
+var moveToTable = ({ collections }, { payload: { id, x, y } }) => {
+	const collection = query(collections).collection("tableEntities");
+	collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.updateOne(id, (table) => {
+		table.ui.x = x;
+		table.ui.y = y;
+	});
+};
+var removeTableAction = createAction(ActionType.removeTable);
+var removeTable = ({ doc, collections, lww }, { payload: { id }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("tableEntities").removeOperator(lww, safeVersion, id, () => {
+		const index = doc.tableIds.indexOf(id);
+		if (index !== -1) doc.tableIds.splice(index, 1);
+	});
+};
+var changeTableNameAction = createAction(ActionType.changeTableName);
+var changeTableName = ({ collections, lww }, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableEntities");
+	collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "name", () => {
+		collection.updateOne(id, (table) => {
+			table.name = value;
+			table.ui.widthName = textInRange(toWidth(value));
+		});
+	});
+};
+var changeTableLogicalNameAction = createAction(ActionType.changeTableLogicalName);
+var changeTableLogicalName = ({ collections, lww }, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableEntities");
+	collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "logicalName", () => {
+		collection.updateOne(id, (table) => {
+			table.logicalName = value;
+			table.ui.widthLogicalName = textInRange(toWidth(value));
+		});
+	});
+};
+var changeTableNameDerivedAction = createAction(ActionType.changeTableNameDerived);
+var changeTableNameDerived = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableEntities");
+	collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "nameDerived", () => {
+		collection.updateOne(id, (table) => {
+			table.nameDerived = value;
+		});
+	});
+};
+var changeTableCommentAction = createAction(ActionType.changeTableComment);
+var changeTableComment = ({ collections, lww }, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableEntities");
+	collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "comment", () => {
+		collection.updateOne(id, (table) => {
+			table.comment = value;
+			table.ui.widthComment = textInRange(toWidth(value));
+		});
+	});
+};
+var changeTableColorAction = createAction(ActionType.changeTableColor);
+var changeTableColor = ({ collections, lww }, { payload: { id, color }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableEntities");
+	collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "ui.color", () => {
+		collection.updateOne(id, (table) => {
+			table.ui.color = color;
+		});
+	});
+};
+var changeTableGroupAction = createAction(ActionType.changeTableGroup);
+var changeTableGroup = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableEntities");
+	collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "groupId", () => {
+		collection.updateOne(id, (table) => {
+			table.groupId = value;
+		});
+	});
+};
+var changeZIndexAction = createAction(ActionType.changeZIndex);
+var changeZIndex = ({ collections }, { payload: { id, zIndex } }) => {
+	const collection = query(collections).collection("tableEntities");
+	collection.getOrCreate(id, (id) => createTable({ id }));
+	collection.updateOne(id, (table) => {
+		table.ui.zIndex = zIndex;
+	});
+};
+var sortTableAction = createAction(ActionType.sortTable);
+function placeInRows(cells, start, width, rowHeight) {
+	let widthSum = start;
+	let currentHeight = start;
+	let maxHeight = rowHeight;
+	cells.forEach((cell) => {
+		const cellWidth = cell.width + 80;
+		const cellHeight = cell.height + 80;
+		if (widthSum + cellWidth > width) {
+			currentHeight += maxHeight;
+			maxHeight = 0;
+			widthSum = start;
+		}
+		if (maxHeight < cellHeight) maxHeight = cellHeight;
+		cell.place(widthSum, currentHeight);
+		widthSum += cellWidth;
+	});
+}
+var tableCell = (state, table) => ({
+	width: calcTableWidths(table, state).width,
+	height: calcTableHeight(table),
+	place: (x, y) => {
+		table.ui.x = x;
+		table.ui.y = y;
+	}
+});
+var sortWidth = ({ doc }) => canvasSizeInRange(doc.tableIds.length * 100);
+function groupCell(state, groupId, members) {
+	const rects = [];
+	placeInRows(members.map((member, index) => ({
+		...member,
+		place: (x, y) => {
+			rects[index] = {
+				x,
+				y,
+				width: member.width,
+				height: member.height
+			};
+		}
+	})), 0, sortWidth(state) - 50 - 48, 0);
+	const box = padRect(rects.reduce(unionRect));
+	return {
+		width: box.width,
+		height: box.height,
+		place: (x, y) => {
+			members.forEach((member, index) => member.place(x + rects[index].x - box.x, y + rects[index].y - box.y));
+			query(state.collections).collection("tableGroupEntities").updateOne(groupId, (group) => {
+				group.ui.x = x;
+				group.ui.y = y;
+				group.ui.width = box.width;
+				group.ui.height = box.height;
+			});
+		}
+	};
+}
+function toSortCells(state, tables) {
+	const membersByGroup = /* @__PURE__ */ new Map();
+	const order = [];
+	tables.forEach((table) => {
+		const cell = tableCell(state, table);
+		const groupId = getTableGroupId(state, table);
+		const members = groupId ? membersByGroup.get(groupId) : void 0;
+		if (!groupId) order.push(cell);
+		else if (members) members.push(cell);
+		else {
+			membersByGroup.set(groupId, [cell]);
+			order.push(groupId);
+		}
+	});
+	return order.map((cell) => typeof cell === "string" ? groupCell(state, cell, membersByGroup.get(cell)) : cell);
+}
+var sortTable = (state) => {
+	const { doc, collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(doc.tableIds);
+	tables.sort((a, b) => a.columnIds.length - b.columnIds.length);
+	placeInRows(toSortCells(state, tables), 50, sortWidth(state), 50);
+};
+var tableReducers = {
+	[ActionType.addTable]: addTable,
+	[ActionType.moveTable]: moveTable,
+	[ActionType.moveToTable]: moveToTable,
+	[ActionType.removeTable]: removeTable,
+	[ActionType.changeTableName]: changeTableName,
+	[ActionType.changeTableComment]: changeTableComment,
+	[ActionType.changeTableColor]: changeTableColor,
+	[ActionType.changeTableGroup]: changeTableGroup,
+	[ActionType.changeZIndex]: changeZIndex,
+	[ActionType.sortTable]: sortTable,
+	[ActionType.changeTableLogicalName]: changeTableLogicalName,
+	[ActionType.changeTableNameDerived]: changeTableNameDerived
+};
+var actions = {
+	addTableAction,
+	moveTableAction,
+	moveToTableAction,
+	removeTableAction,
+	changeTableNameAction,
+	changeTableCommentAction,
+	changeTableColorAction,
+	changeTableGroupAction,
+	changeZIndexAction,
+	sortTableAction,
+	changeTableLogicalNameAction,
+	changeTableNameDerivedAction
+};
+//#endregion
+export { actions, addTableAction, changeTableColorAction, changeTableCommentAction, changeTableGroupAction, changeTableLogicalNameAction, changeTableNameAction, changeTableNameDerivedAction, changeZIndexAction, moveTableAction, moveToTableAction, removeTableAction, sortTableAction, tableReducers };

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

@@ -0,0 +1,351 @@
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, ColumnType } from "../../../constants/schema.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { toPastedDomainId } from "../dictionary/membership.js";
+import { addColumnAction, changeColumnAutoIncrementAction, changeColumnCommentAction, changeColumnDataTypeAction, changeColumnDefaultAction, changeColumnDomainAction, changeColumnLogicalNameAction, changeColumnNameAction, changeColumnNameDerivedAction, changeColumnNotNullAction, changeColumnUniqueAction } from "../table-column/atom.actions.js";
+import { toDomainUnlinkActions } from "../dictionary/domainTypes.js";
+import { SelectType } from "../editor/state.js";
+import { bHas } from "../../../utils/bit.js";
+import { isDomainInTypeCell } from "../editor/utils/nameView.js";
+import { getTableGroupId } from "../../../utils/tableGroup.js";
+import { nextPoint, nextZIndex } from "../../../utils/index.js";
+import { isTableFocusType } from "../editor/utils/focus.js";
+import { drawEndRelationshipAction, focusColumnAction, focusTableAction, focusTableEndAction, selectAction, unselectAllAction } from "../editor/atom.actions.js";
+import { removeIndexAction } from "../index/atom.actions.js";
+import { addRelationshipAction, removeRelationshipAction } from "../relationship/atom.actions.js";
+import { ActionType } from "./actions.js";
+import { addTableAction, changeTableNameAction, changeTableNameDerivedAction, changeZIndexAction, moveToTableAction, removeTableAction, tableReducers } from "./atom.actions.js";
+import { resizeTableGroupAction } from "../table-group/atom.actions.js";
+import { getStartKeyColumns, toForeignKeyActions } from "../relationship/fkColumns.js";
+import { toColumnNameWrites } from "../dictionary/derivedNames.js";
+import { getShowColumnOrder } from "../../../utils/table-clipboard/index.js";
+import { drawStartAddRelationshipAction$ } from "../editor/generator.actions.js";
+//#region src/engine/modules/table/generator.actions.ts
+var addTableAction$ = () => 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 addTableAction({
+		id,
+		ui: {
+			...point,
+			zIndex: nextZIndex(tables, memos)
+		}
+	});
+	yield selectAction({ [id]: SelectType.table });
+	yield focusTableAction({ tableId: id });
+};
+var removeTableAction$ = (id) => function* ({ doc: { tableIds, relationshipIds, indexIds }, editor: { selectedMap }, collections }) {
+	const relationships = query(collections).collection("relationshipEntities").selectByIds(relationshipIds);
+	const indexes = query(collections).collection("indexEntities").selectByIds(indexIds);
+	if (id) {
+		const removeRelationships = relationships.filter(({ start, end }) => start.tableId === id || end.tableId === id);
+		const removeIndexes = indexes.filter(({ tableId }) => tableId === id);
+		for (const { id } of removeIndexes) yield removeIndexAction({ id });
+		for (const { id } of removeRelationships) yield removeRelationshipAction({ id });
+		yield removeTableAction({ id });
+		return;
+	}
+	const isInDoc = arrayHas(tableIds);
+	const selectedTableIds = Object.entries(selectedMap).filter(([id, type]) => type === SelectType.table && isInDoc(id)).map(([id]) => id);
+	const hasTableIds = arrayHas(selectedTableIds);
+	const removeRelationships = relationships.filter(({ start, end }) => hasTableIds(start.tableId) || hasTableIds(end.tableId));
+	const removeIndexes = indexes.filter(({ tableId }) => hasTableIds(tableId));
+	for (const { id } of removeIndexes) yield removeIndexAction({ id });
+	for (const { id } of removeRelationships) yield removeRelationshipAction({ id });
+	for (const id of selectedTableIds) yield removeTableAction({ id });
+};
+var selectTableAction$ = (id, $mod) => function* ({ doc: { tableIds, memoIds, domainIds }, collections, editor: { drawRelationship }, settings: { database } }) {
+	const tableCollection = query(collections).collection("tableEntities");
+	const tables = tableCollection.selectByIds(tableIds);
+	const memos = query(collections).collection("memoEntities").selectByIds(memoIds);
+	if (!$mod) yield unselectAllAction();
+	yield selectAction({ [id]: SelectType.table });
+	yield changeZIndexAction({
+		id,
+		zIndex: nextZIndex(tables, memos)
+	});
+	yield focusTableAction({ tableId: id });
+	if (!drawRelationship) return;
+	if (drawRelationship.start) {
+		const startTable = tableCollection.selectById(drawRelationship.start.tableId);
+		const endTable = tableCollection.selectById(id);
+		if (!startTable || !endTable) {
+			yield drawEndRelationshipAction();
+			return;
+		}
+		const columnCollection = query(collections).collection("tableColumnEntities");
+		const startColumns = getStartKeyColumns(collections, startTable);
+		if (!startColumns.length) {
+			yield drawEndRelationshipAction();
+			return;
+		}
+		const endColumnIds = startColumns.map(() => uuid25());
+		yield toForeignKeyActions(startColumns, endTable.id, endColumnIds, {
+			startTableName: startTable.name,
+			endColumnNames: columnCollection.selectByIds(endTable.columnIds).map(({ name }) => name),
+			database,
+			domainIds
+		});
+		yield addRelationshipAction({
+			id: uuid25(),
+			relationshipType: drawRelationship.relationshipType,
+			start: {
+				tableId: startTable.id,
+				columnIds: startColumns.map(({ id }) => id)
+			},
+			end: {
+				tableId: endTable.id,
+				columnIds: endColumnIds
+			}
+		});
+		yield drawEndRelationshipAction();
+	} else yield drawStartAddRelationshipAction$(id);
+};
+var EVERY_CELL = {
+	name: true,
+	logicalName: true,
+	dataType: true,
+	domain: true
+};
+function toPastedCells(settings, showColumnOrder) {
+	const dataType = showColumnOrder.includes(ColumnType.columnDataType);
+	return {
+		name: showColumnOrder.includes(ColumnType.columnName),
+		logicalName: showColumnOrder.includes(ColumnType.columnLogicalName),
+		dataType,
+		domain: showColumnOrder.includes(ColumnType.columnDomain) || dataType && isDomainInTypeCell(settings)
+	};
+}
+function toPastedValueActions(payload, column, showColumnOrder) {
+	return showColumnOrder.flatMap((columnType) => {
+		switch (columnType) {
+			case ColumnType.columnDefault: return [changeColumnDefaultAction({
+				...payload,
+				value: column.default
+			})];
+			case ColumnType.columnComment: return [changeColumnCommentAction({
+				...payload,
+				value: column.comment
+			})];
+			case ColumnType.columnAutoIncrement: return [changeColumnAutoIncrementAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.autoIncrement)
+			})];
+			case ColumnType.columnUnique: return [changeColumnUniqueAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.unique)
+			})];
+			case ColumnType.columnNotNull: return [changeColumnNotNullAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.notNull)
+			})];
+			default: return [];
+		}
+	});
+}
+function toPastedNameDomainActions(state, payload, current, pasted, cells) {
+	const actions = [];
+	const wasDerived = current ? bHas(current.options, ColumnOption.nameDerived) : false;
+	const domainTypeOf = (id) => state.collections.domainEntities[id]?.dataType ?? "";
+	if (cells.name) {
+		actions.push(changeColumnNameAction({
+			...payload,
+			value: pasted.name
+		}));
+		if (wasDerived) actions.push(changeColumnNameDerivedAction({
+			...payload,
+			value: false
+		}));
+	}
+	let link = cells.domain ? toPastedDomainId(state, pasted.domainId, pasted.dataType) : null;
+	const dataType = cells.dataType ? pasted.dataType : null;
+	if (cells.logicalName) {
+		actions.push(changeColumnLogicalNameAction({
+			...payload,
+			value: pasted.logicalName
+		}));
+		const left = {
+			...pasted,
+			id: payload.id,
+			name: cells.name ? pasted.name : current?.name ?? "",
+			options: !cells.name && wasDerived ? ColumnOption.nameDerived : 0
+		};
+		const writes = toColumnNameWrites(state, payload.tableId, left, pasted.logicalName);
+		const termDomainId = writes.link?.value ?? "";
+		actions.push(...writes.actions);
+		if (termDomainId && !link && (!dataType || domainTypeOf(termDomainId) === dataType)) link = termDomainId;
+	}
+	if (link) {
+		const domainType = domainTypeOf(link);
+		if (current?.domainId !== link) actions.push(changeColumnDomainAction({
+			...payload,
+			value: link
+		}));
+		if (dataType !== null || current?.dataType !== domainType) actions.push(changeColumnDataTypeAction({
+			...payload,
+			value: domainType
+		}));
+		return actions;
+	}
+	if (link === "" && current?.domainId !== "") actions.push(changeColumnDomainAction({
+		...payload,
+		value: ""
+	}));
+	if (dataType !== null) {
+		actions.push(changeColumnDataTypeAction({
+			...payload,
+			value: dataType
+		}));
+		if (link === null) actions.push(...toDomainUnlinkActions(state, [{
+			...payload,
+			value: dataType
+		}]));
+	}
+	return actions;
+}
+var pasteTableAction$ = (columns) => function* (state) {
+	const { editor: { selectedMap, focusTable }, settings, collections } = state;
+	const isFit = focusTable && !isTableFocusType(focusTable.focusType);
+	const selectedTableIds = Object.entries(selectedMap).filter(([, type]) => type === SelectType.table).map(([id]) => id).filter((id) => isFit ? id !== focusTable?.tableId : true);
+	for (const tableId of selectedTableIds) for (const column of columns) {
+		const payload = {
+			id: uuid25(),
+			tableId
+		};
+		yield [
+			addColumnAction(payload),
+			changeColumnDefaultAction({
+				...payload,
+				value: column.default
+			}),
+			changeColumnCommentAction({
+				...payload,
+				value: column.comment
+			}),
+			changeColumnNotNullAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.notNull)
+			}),
+			changeColumnUniqueAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.unique)
+			}),
+			changeColumnAutoIncrementAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.autoIncrement)
+			}),
+			...toPastedNameDomainActions(state, payload, void 0, column, EVERY_CELL)
+		];
+	}
+	if (!focusTable || !isFit) return;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return;
+	const columnIds = table.columnIds.filter(arrayHas(focusTable.selectColumnIds));
+	if (columnIds.length === 0) return;
+	const additionalColumnIds = table.columnIds.slice(table.columnIds.indexOf(columnIds[columnIds.length - 1]) + 1);
+	const columnIdsRange = [...columnIds, ...additionalColumnIds];
+	const showColumnOrder = getShowColumnOrder(settings.show, settings.columnOrder, settings.nameViewMode);
+	const cells = toPastedCells(settings, showColumnOrder);
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	yield focusTableEndAction();
+	for (let i = 0; i < columnIdsRange.length; i++) {
+		const columnId = columnIdsRange[i];
+		const column = columns[i];
+		if (!column) break;
+		const payload = {
+			id: columnId,
+			tableId: table.id
+		};
+		yield [
+			...toPastedValueActions(payload, column, showColumnOrder),
+			...toPastedNameDomainActions(state, payload, columnCollection.selectById(columnId), column, cells),
+			focusColumnAction({
+				tableId: table.id,
+				columnId,
+				focusType: focusTable.focusType,
+				$mod: true,
+				shiftKey: false
+			})
+		];
+	}
+	const addColumns = columns.slice(columnIdsRange.length);
+	for (const column of addColumns) {
+		const id = uuid25();
+		const payload = {
+			id,
+			tableId: table.id
+		};
+		yield [
+			addColumnAction(payload),
+			...toPastedValueActions(payload, column, showColumnOrder),
+			...toPastedNameDomainActions(state, payload, void 0, column, cells),
+			focusColumnAction({
+				tableId: table.id,
+				columnId: id,
+				focusType: focusTable.focusType,
+				$mod: true,
+				shiftKey: false
+			})
+		];
+	}
+};
+var sortTablesToMoveAction$ = () => function* (state, context) {
+	const { doc, collections } = state;
+	const copies = query(collections).collection("tableEntities").selectByIds(doc.tableIds).map((table) => ({
+		...table,
+		ui: { ...table.ui }
+	}));
+	const groups = query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds).map((group) => ({
+		...group,
+		ui: { ...group.ui }
+	}));
+	const sorted = {
+		...state,
+		collections: {
+			...collections,
+			tableEntities: Object.fromEntries(copies.map((table) => [table.id, table])),
+			tableGroupEntities: Object.fromEntries(groups.map((group) => [group.id, group]))
+		}
+	};
+	tableReducers[ActionType.sortTable](sorted, {
+		type: ActionType.sortTable,
+		payload: void 0
+	}, context);
+	const placedGroupIds = new Set(copies.map((table) => getTableGroupId(sorted, table)));
+	yield copies.map(({ id, ui: { x, y } }) => moveToTableAction({
+		id,
+		x,
+		y
+	}));
+	yield groups.filter(({ id }) => placedGroupIds.has(id)).map(({ id, ui: { x, y, width, height } }) => resizeTableGroupAction({
+		id,
+		x,
+		y,
+		width,
+		height
+	}));
+};
+var changeTableNameAction$ = (id, value) => function* ({ collections }) {
+	const table = query(collections).collection("tableEntities").selectById(id);
+	yield [changeTableNameAction({
+		id,
+		value
+	}), ...table?.nameDerived ? [changeTableNameDerivedAction({
+		id,
+		value: false
+	})] : []];
+};
+var actions$ = {
+	addTableAction$,
+	removeTableAction$,
+	selectTableAction$,
+	pasteTableAction$,
+	sortTablesToMoveAction$,
+	changeTableNameAction$
+};
+//#endregion
+export { actions$, addTableAction$, changeTableNameAction$, pasteTableAction$, removeTableAction$, selectTableAction$, sortTablesToMoveAction$ };