@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,134 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ActionType } from "./actions.js";
+import { addTableAction, changeTableColorAction, changeTableCommentAction, changeTableGroupAction, changeTableLogicalNameAction, changeTableNameAction, changeTableNameDerivedAction, moveTableAction, moveToTableAction, removeTableAction } from "./atom.actions.js";
+import { groupBy, head, isString, last, pick } from "es-toolkit";
+//#region src/engine/modules/table/history.ts
+var MOVE_MIN = 20;
+var addTable = (undoActions, { payload: { id } }) => {
+	undoActions.push(removeTableAction({ id }));
+};
+var removeTable = (undoActions, { payload: { id } }, { collections }) => {
+	const table = query(collections).collection("tableEntities").selectById(id);
+	if (!table) return;
+	undoActions.push(addTableAction({
+		id: table.id,
+		ui: pick(table.ui, [
+			"x",
+			"y",
+			"zIndex"
+		])
+	}));
+};
+var changeTableName = (undoActions, { payload: { id } }, { collections }) => {
+	const table = query(collections).collection("tableEntities").selectById(id);
+	if (!table) return;
+	undoActions.push(changeTableNameAction({
+		id,
+		value: table.name
+	}));
+};
+var changeTableLogicalName = (undoActions, { payload: { id } }, { collections }) => {
+	const table = query(collections).collection("tableEntities").selectById(id);
+	if (!table) return;
+	undoActions.push(changeTableLogicalNameAction({
+		id,
+		value: table.logicalName
+	}));
+};
+var changeTableNameDerived = (undoActions, { payload: { id } }, { collections }) => {
+	const table = query(collections).collection("tableEntities").selectById(id);
+	if (!table) return;
+	undoActions.push(changeTableNameDerivedAction({
+		id,
+		value: table.nameDerived
+	}));
+};
+var changeTableComment = (undoActions, { payload: { id } }, { collections }) => {
+	const table = query(collections).collection("tableEntities").selectById(id);
+	if (!table) return;
+	undoActions.push(changeTableCommentAction({
+		id,
+		value: table.comment
+	}));
+};
+var changeTableGroup = (undoActions, { payload: { id, prevValue } }, { collections }) => {
+	const table = query(collections).collection("tableEntities").selectById(id);
+	if (!table) return;
+	undoActions.push(changeTableGroupAction({
+		id,
+		value: isString(prevValue) ? prevValue : table.groupId
+	}));
+};
+var moveToTable = (undoActions, { payload: { id } }, { collections }) => {
+	const table = query(collections).collection("tableEntities").selectById(id);
+	if (!table) return;
+	undoActions.push(moveToTableAction({
+		id,
+		x: table.ui.x,
+		y: table.ui.y
+	}));
+};
+var sortTable = () => {};
+var tablePushUndoHistoryMap = {
+	[ActionType.addTable]: addTable,
+	[ActionType.removeTable]: removeTable,
+	[ActionType.changeTableName]: changeTableName,
+	[ActionType.changeTableComment]: changeTableComment,
+	[ActionType.changeTableGroup]: changeTableGroup,
+	[ActionType.moveToTable]: moveToTable,
+	[ActionType.sortTable]: sortTable,
+	[ActionType.changeTableLogicalName]: changeTableLogicalName,
+	[ActionType.changeTableNameDerived]: changeTableNameDerived
+};
+var moveTable = (undoActions, redoActions, actions) => {
+	const moveTableActions = actions.filter((action) => action.type === moveTableAction.type);
+	if (!moveTableActions.length) return;
+	const group = groupBy(moveTableActions, (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(moveTableAction({
+			ids,
+			movementX: -1 * x,
+			movementY: -1 * y
+		}));
+		redoActions.push(moveTableAction({
+			ids,
+			movementX: x,
+			movementY: y
+		}));
+	}
+};
+var changeTableColor = (undoActions, redoActions, actions) => {
+	const changeTableColorActions = actions.filter(({ type }) => type === changeTableColorAction.type);
+	if (!changeTableColorActions.length) return;
+	const group = groupBy(changeTableColorActions, (action) => action.payload.id);
+	for (const [id, actions] of Object.entries(group)) {
+		const firstAction = head(actions);
+		const lastAction = last(actions);
+		undoActions.push(changeTableColorAction({
+			id,
+			color: firstAction.payload.prevColor,
+			prevColor: lastAction.payload.color
+		}));
+		redoActions.push(changeTableColorAction({
+			id,
+			color: lastAction.payload.color,
+			prevColor: firstAction.payload.prevColor
+		}));
+	}
+};
+var tablePushStreamHistoryMap = {
+	[ActionType.moveTable]: moveTable,
+	[ActionType.changeTableColor]: changeTableColor
+};
+//#endregion
+export { tablePushStreamHistoryMap, tablePushUndoHistoryMap };

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

@@ -0,0 +1,12 @@
+import { removeTableAction } from "./atom.actions.js";
+import { asapScheduler, observeOn } from "rxjs";
+//#region src/engine/modules/table/hooks.ts
+var endDrawFromRemovedTableHook = (action$, getState) => action$.pipe(observeOn(asapScheduler)).subscribe(() => {
+	const { doc, editor } = getState();
+	const start = editor.drawRelationship?.start;
+	if (!start || doc.tableIds.includes(start.tableId)) return;
+	editor.drawRelationship = null;
+});
+var hooks = [[[removeTableAction], endDrawFromRemovedTableHook]];
+//#endregion
+export { hooks };

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

@@ -0,0 +1,19 @@
+//#region src/engine/modules/table-column/actions.ts
+var ActionType = {
+	addColumn: "column.add",
+	removeColumn: "column.remove",
+	changeColumnName: "column.changeName",
+	changeColumnComment: "column.changeComment",
+	changeColumnDataType: "column.changeDataType",
+	changeColumnDefault: "column.changeDefault",
+	changeColumnAutoIncrement: "column.changeAutoIncrement",
+	changeColumnPrimaryKey: "column.changePrimaryKey",
+	changeColumnUnique: "column.changeUnique",
+	changeColumnNotNull: "column.changeNotNull",
+	moveColumn: "column.move",
+	changeColumnLogicalName: "column.changeLogicalName",
+	changeColumnDomain: "column.changeDomain",
+	changeColumnNameDerived: "column.changeNameDerived"
+};
+//#endregion
+export { ActionType };

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

@@ -0,0 +1,223 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, ColumnUIKey } from "../../../constants/schema.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { textInRange } from "../../../utils/validation.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { relinkDomainColumn } from "../dictionary/domainLinks.js";
+import { getLiveDomainName } from "../dictionary/membership.js";
+import { addAndSort } from "../../../utils/collection/sequence.js";
+import { createTable } from "../../../utils/collection/table.entity.js";
+import { createColumn } from "../../../utils/collection/tableColumn.entity.js";
+import { ActionType } from "./actions.js";
+//#region src/engine/modules/table-column/atom.actions.ts
+var addColumnAction = createAction(ActionType.addColumn);
+var addColumn = ({ collections, lww }, { payload: { id, tableId }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const tableCollection = query(collections).collection("tableEntities");
+	const table = tableCollection.getOrCreate(tableId, (id) => createTable({ id }));
+	query(collections).collection("tableColumnEntities").addOne(createColumn({
+		id,
+		tableId
+	})).addOperator(lww, safeVersion, id, () => {
+		if (!arrayHas(table.columnIds)(id)) tableCollection.updateOne(tableId, (table) => {
+			addAndSort(table.columnIds, table.seqColumnIds, id);
+		});
+	});
+};
+var removeColumnAction = createAction(ActionType.removeColumn);
+var removeColumn = ({ collections, lww }, { payload: { id, tableId }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const tableCollection = query(collections).collection("tableEntities");
+	const table = tableCollection.getOrCreate(tableId, (id) => createTable({ id }));
+	query(collections).collection("tableColumnEntities").removeOperator(lww, safeVersion, id, () => {
+		const index = table.columnIds.indexOf(id);
+		if (index !== -1) tableCollection.updateOne(tableId, (table) => {
+			table.columnIds.splice(index, 1);
+		});
+	});
+};
+var changeColumnNameAction = createAction(ActionType.changeColumnName);
+var changeColumnName = ({ collections, lww }, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "name", () => {
+		collection.updateOne(id, (column) => {
+			column.name = value;
+			column.ui.widthName = textInRange(toWidth(value));
+		});
+	});
+};
+var changeColumnCommentAction = createAction(ActionType.changeColumnComment);
+var changeColumnComment = ({ collections, lww }, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "comment", () => {
+		collection.updateOne(id, (column) => {
+			column.comment = value;
+			column.ui.widthComment = textInRange(toWidth(value));
+		});
+	});
+};
+var changeColumnDataTypeAction = createAction(ActionType.changeColumnDataType);
+var DATA_TYPE = "dataType";
+var changeColumnDataType = ({ collections, lww }, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	const column = collection.getOrCreate(id, (id) => createColumn({ id }));
+	if ((lww[id]?.[3][DATA_TYPE] ?? -1) === safeVersion && value <= column.dataType) return;
+	collection.replaceOperator(lww, safeVersion, id, DATA_TYPE, () => {
+		collection.updateOne(id, (column) => {
+			column.dataType = value;
+			column.ui.widthDataType = textInRange(toWidth(value));
+		});
+	});
+};
+var changeColumnDefaultAction = createAction(ActionType.changeColumnDefault);
+var changeColumnDefault = ({ collections, lww }, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "default", () => {
+		collection.updateOne(id, (column) => {
+			column.default = value;
+			column.ui.widthDefault = textInRange(toWidth(value));
+		});
+	});
+};
+var changeColumnAutoIncrementAction = createAction(ActionType.changeColumnAutoIncrement);
+var changeColumnAutoIncrement = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "options(autoIncrement)", () => {
+		collection.updateOne(id, (column) => {
+			column.options = value ? column.options | ColumnOption.autoIncrement : column.options & ~ColumnOption.autoIncrement;
+		});
+	});
+};
+var changeColumnPrimaryKeyAction = createAction(ActionType.changeColumnPrimaryKey);
+var changeColumnPrimaryKey = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "options(primaryKey)", () => {
+		collection.updateOne(id, (column) => {
+			column.options = value ? column.options | ColumnOption.primaryKey : column.options & ~ColumnOption.primaryKey;
+			column.ui.keys = value ? column.ui.keys | ColumnUIKey.primaryKey : column.ui.keys & ~ColumnUIKey.primaryKey;
+		});
+	});
+};
+var changeColumnUniqueAction = createAction(ActionType.changeColumnUnique);
+var changeColumnUnique = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "options(unique)", () => {
+		collection.updateOne(id, (column) => {
+			column.options = value ? column.options | ColumnOption.unique : column.options & ~ColumnOption.unique;
+		});
+	});
+};
+var changeColumnNotNullAction = createAction(ActionType.changeColumnNotNull);
+var changeColumnNotNull = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "options(notNull)", () => {
+		collection.updateOne(id, (column) => {
+			column.options = value ? column.options | ColumnOption.notNull : column.options & ~ColumnOption.notNull;
+		});
+	});
+};
+var changeColumnLogicalNameAction = createAction(ActionType.changeColumnLogicalName);
+var changeColumnLogicalName = ({ collections, lww }, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "logicalName", () => {
+		collection.updateOne(id, (column) => {
+			column.logicalName = value;
+			column.ui.widthLogicalName = textInRange(toWidth(value));
+		});
+	});
+};
+var changeColumnDomainAction = createAction(ActionType.changeColumnDomain);
+var changeColumnDomain = (state, { payload: { id, value }, version }, { toWidth, clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(state.collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(state.lww, safeVersion, id, "domainId", () => {
+		collection.updateOne(id, (column) => {
+			relinkDomainColumn(state, id, column.domainId, value);
+			column.domainId = value;
+			column.ui.widthDomain = textInRange(toWidth(getLiveDomainName(state, value)));
+		});
+	});
+};
+var changeColumnNameDerivedAction = createAction(ActionType.changeColumnNameDerived);
+var changeColumnNameDerived = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("tableColumnEntities");
+	collection.getOrCreate(id, (id) => createColumn({ id }));
+	collection.replaceOperator(lww, safeVersion, id, "options(nameDerived)", () => {
+		collection.updateOne(id, (column) => {
+			column.options = value ? column.options | ColumnOption.nameDerived : column.options & ~ColumnOption.nameDerived;
+		});
+	});
+};
+var moveColumnAction = createAction(ActionType.moveColumn);
+var moveColumn = ({ collections }, { payload: { id, tableId, targetId } }) => {
+	if (id === targetId) return;
+	const tableCollection = query(collections).collection("tableEntities");
+	const table = tableCollection.getOrCreate(tableId, (id) => createTable({ id }));
+	const index = table.columnIds.indexOf(id);
+	if (index === -1) return;
+	const targetIndex = table.columnIds.indexOf(targetId);
+	if (targetIndex === -1) return;
+	tableCollection.updateOne(tableId, (table) => {
+		table.columnIds.splice(index, 1);
+		table.columnIds.splice(targetIndex, 0, id);
+		const seqIndex = table.seqColumnIds.indexOf(id);
+		const seqTargetIndex = table.seqColumnIds.indexOf(targetId);
+		if (seqIndex !== -1 && seqTargetIndex !== -1) {
+			table.seqColumnIds.splice(seqIndex, 1);
+			table.seqColumnIds.splice(seqTargetIndex, 0, id);
+		}
+	});
+};
+var tableColumnReducers = {
+	[ActionType.addColumn]: addColumn,
+	[ActionType.removeColumn]: removeColumn,
+	[ActionType.changeColumnName]: changeColumnName,
+	[ActionType.changeColumnComment]: changeColumnComment,
+	[ActionType.changeColumnDataType]: changeColumnDataType,
+	[ActionType.changeColumnDefault]: changeColumnDefault,
+	[ActionType.changeColumnAutoIncrement]: changeColumnAutoIncrement,
+	[ActionType.changeColumnPrimaryKey]: changeColumnPrimaryKey,
+	[ActionType.changeColumnUnique]: changeColumnUnique,
+	[ActionType.changeColumnNotNull]: changeColumnNotNull,
+	[ActionType.moveColumn]: moveColumn,
+	[ActionType.changeColumnLogicalName]: changeColumnLogicalName,
+	[ActionType.changeColumnDomain]: changeColumnDomain,
+	[ActionType.changeColumnNameDerived]: changeColumnNameDerived
+};
+var actions = {
+	addColumnAction,
+	removeColumnAction,
+	changeColumnNameAction,
+	changeColumnCommentAction,
+	changeColumnDataTypeAction,
+	changeColumnDefaultAction,
+	changeColumnAutoIncrementAction,
+	changeColumnPrimaryKeyAction,
+	changeColumnUniqueAction,
+	changeColumnNotNullAction,
+	moveColumnAction,
+	changeColumnLogicalNameAction,
+	changeColumnDomainAction,
+	changeColumnNameDerivedAction
+};
+//#endregion
+export { actions, addColumnAction, changeColumnAutoIncrementAction, changeColumnCommentAction, changeColumnDataTypeAction, changeColumnDefaultAction, changeColumnDomainAction, changeColumnLogicalNameAction, changeColumnNameAction, changeColumnNameDerivedAction, changeColumnNotNullAction, changeColumnPrimaryKeyAction, changeColumnUniqueAction, moveColumnAction, removeColumnAction, tableColumnReducers };

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

@@ -0,0 +1,165 @@
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../../constants/schema.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { addColumnAction, changeColumnAutoIncrementAction, changeColumnCommentAction, changeColumnDefaultAction, changeColumnLogicalNameAction, changeColumnNameAction, changeColumnNameDerivedAction, changeColumnNotNullAction, changeColumnPrimaryKeyAction, changeColumnUniqueAction, removeColumnAction } from "./atom.actions.js";
+import { toDomainTypeActions } from "../dictionary/domainTypes.js";
+import { FocusType, SelectType } from "../editor/state.js";
+import { bHas } from "../../../utils/bit.js";
+import { getFirstColumnType, getRemoveFirstColumnId } from "../editor/utils/focus.js";
+import { focusColumnAction, focusTableAction } from "../editor/atom.actions.js";
+import { removeIndexAction } from "../index/atom.actions.js";
+import { removeRelationshipAction } from "../relationship/atom.actions.js";
+import { last } from "es-toolkit";
+//#region src/engine/modules/table-column/generator.actions.ts
+var isToggleColumnTypes = arrayHas([
+	FocusType.columnNotNull,
+	FocusType.columnUnique,
+	FocusType.columnAutoIncrement
+]);
+var isChangeColumnTypes = arrayHas([
+	FocusType.columnName,
+	FocusType.columnLogicalName,
+	FocusType.columnDataType,
+	FocusType.columnDefault,
+	FocusType.columnComment
+]);
+var addColumnAction$ = (tableId) => function* (state) {
+	const { editor: { selectedMap } } = state;
+	const focusType = getFirstColumnType(state);
+	if (tableId) {
+		const id = uuid25();
+		yield addColumnAction({
+			id,
+			tableId
+		});
+		yield focusColumnAction({
+			tableId,
+			columnId: id,
+			focusType,
+			$mod: false,
+			shiftKey: false
+		});
+		return;
+	}
+	const addColumnActions = Object.entries(selectedMap).filter(([, type]) => type === SelectType.table).map(([tableId]) => ({
+		tableId,
+		id: uuid25()
+	}));
+	for (const payload of addColumnActions) yield addColumnAction(payload);
+	const lastAction = last(addColumnActions);
+	if (lastAction) yield focusColumnAction({
+		tableId: lastAction.tableId,
+		columnId: lastAction.id,
+		focusType,
+		$mod: false,
+		shiftKey: false
+	});
+};
+var removeColumnAction$ = (tableId, columnIds) => function* (state) {
+	const { doc: { relationshipIds, indexIds }, editor: { focusTable }, collections } = state;
+	if (focusTable?.columnId) {
+		const columnId = getRemoveFirstColumnId(state, columnIds);
+		if (columnId) yield focusColumnAction({
+			tableId: focusTable.tableId,
+			columnId,
+			focusType: focusTable.focusType,
+			$mod: false,
+			shiftKey: false
+		});
+		else yield focusTableAction({
+			tableId: focusTable.tableId,
+			focusType: FocusType.tableName
+		});
+	}
+	const hasColumnIds = arrayHas(columnIds);
+	const relationships = query(collections).collection("relationshipEntities").selectByIds(relationshipIds).filter(({ start, end }) => start.tableId === tableId && start.columnIds.some(hasColumnIds) || end.tableId === tableId && end.columnIds.some(hasColumnIds));
+	const indexes = query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === tableId && query(collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).map(({ columnId }) => columnId).some(hasColumnIds));
+	for (const { id } of indexes) yield removeIndexAction({ id });
+	for (const { id } of relationships) yield removeRelationshipAction({ id });
+	for (const columnId of columnIds) yield removeColumnAction({
+		id: columnId,
+		tableId
+	});
+};
+var toggleColumnValueAction$ = (focusType, tableId, columnId) => function* ({ collections }) {
+	if (!isToggleColumnTypes(focusType)) return;
+	const column = query(collections).collection("tableColumnEntities").selectById(columnId);
+	if (!column) return;
+	switch (focusType) {
+		case FocusType.columnNotNull:
+			yield changeColumnNotNullAction({
+				id: columnId,
+				tableId,
+				value: !bHas(column.options, ColumnOption.notNull)
+			});
+			break;
+		case FocusType.columnUnique:
+			yield changeColumnUniqueAction({
+				id: columnId,
+				tableId,
+				value: !bHas(column.options, ColumnOption.unique)
+			});
+			break;
+		case FocusType.columnAutoIncrement: yield changeColumnAutoIncrementAction({
+			id: columnId,
+			tableId,
+			value: !bHas(column.options, ColumnOption.autoIncrement)
+		});
+	}
+};
+var changeColumnDataTypeAction$ = (payload) => function* (state) {
+	yield toDomainTypeActions(state, { dataTypes: [payload] });
+};
+var changeColumnValueAction$ = (focusType, tableId, columnId, value) => function* ({ collections }) {
+	if (!isChangeColumnTypes(focusType)) return;
+	const column = query(collections).collection("tableColumnEntities").selectById(columnId);
+	if (!column) return;
+	const payload = {
+		id: columnId,
+		tableId,
+		value
+	};
+	switch (focusType) {
+		case FocusType.columnName:
+			yield [changeColumnNameAction(payload), ...bHas(column.options, ColumnOption.nameDerived) ? [changeColumnNameDerivedAction({
+				...payload,
+				value: false
+			})] : []];
+			break;
+		case FocusType.columnLogicalName:
+			yield changeColumnLogicalNameAction(payload);
+			break;
+		case FocusType.columnDataType:
+			yield changeColumnDataTypeAction$(payload);
+			break;
+		case FocusType.columnDefault:
+			yield changeColumnDefaultAction(payload);
+			break;
+		case FocusType.columnComment: yield changeColumnCommentAction(payload);
+	}
+};
+var changeColumnsPrimaryKeyAction$ = (tableId, columnIds) => function* ({ collections }) {
+	const table = query(collections).collection("tableEntities").selectById(tableId);
+	if (!table) return;
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(columnIds.filter(arrayHas(table.columnIds)));
+	const isPrimaryKey = ({ options }) => bHas(options, ColumnOption.primaryKey);
+	const value = !columns.every(isPrimaryKey);
+	yield columns.filter((column) => isPrimaryKey(column) !== value).map(({ id }) => changeColumnPrimaryKeyAction({
+		tableId,
+		id,
+		value
+	}));
+};
+var changeColumnPrimaryKeyAction$ = (tableId, columnId) => changeColumnsPrimaryKeyAction$(tableId, [columnId]);
+var actions$ = {
+	addColumnAction$,
+	removeColumnAction$,
+	toggleColumnValueAction$,
+	changeColumnDataTypeAction$,
+	changeColumnValueAction$,
+	changeColumnPrimaryKeyAction$,
+	changeColumnsPrimaryKeyAction$
+};
+//#endregion
+export { actions$, addColumnAction$, changeColumnDataTypeAction$, changeColumnPrimaryKeyAction$, changeColumnValueAction$, changeColumnsPrimaryKeyAction$, isChangeColumnTypes, isToggleColumnTypes, removeColumnAction$, toggleColumnValueAction$ };