@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,761 @@
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { parser } from "../../../erd-editor-schema/dist/parser.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../../constants/schema.js";
+import { toPastedDomainId } from "../dictionary/membership.js";
+import { addColumnAction, changeColumnAutoIncrementAction, changeColumnCommentAction, changeColumnDataTypeAction, changeColumnDefaultAction, changeColumnDomainAction, changeColumnLogicalNameAction, changeColumnNameAction, changeColumnNameDerivedAction, changeColumnNotNullAction, changeColumnPrimaryKeyAction, changeColumnUniqueAction, moveColumnAction } from "../table-column/atom.actions.js";
+import { FocusType, MoveKey, SelectType } from "./state.js";
+import { bHas } from "../../../utils/bit.js";
+import { viewMoveTableAction } from "./view.actions.js";
+import { Tag, attachActionTag } from "../../tag.js";
+import { isMemoShown } from "../../../utils/memo.js";
+import { getVisibleIds } from "../../../konva/scene/viewLayout.js";
+import { calcMemoHeight, calcMemoWidth } from "../../../utils/calcMemo.js";
+import { measureTableSize, recalculateTableWidth } from "../../../utils/calcTable.js";
+import { getMemoRect, getTableRect, unionRect } from "../../../konva/scene/metrics.js";
+import { getTableGroupRects, isTableGroupShown, nextTableGroupZIndex, padRect } from "../../../utils/tableGroup.js";
+import { getContentRect } from "../../../konva/scene/contentBounds.js";
+import { getSceneTransform } from "../../../konva/scene/viewport.js";
+import { nextZIndex } from "../../../utils/index.js";
+import { getFirstColumnType, getFocusedColumnIds, isColumns, isLastColumn, isLastRowColumn, isLastTable, isTableFocusType } from "./utils/focus.js";
+import { clearAction, dragstartColumnAction, drawEndRelationshipAction, drawStartAddRelationshipAction, drawStartRelationshipAction, focusColumnAction, focusMoveTableAction, focusTableEndAction, hoverColumnMapAction, hoverRelationshipMapAction, initialClearAction, initialLoadJsonAction, loadJsonAction, selectAction, unselectAllAction } from "./atom.actions.js";
+import { changeMemoColorAction, moveMemoAction } from "../memo/atom.actions.js";
+import { ActionType } from "../table/actions.js";
+import { changeTableColorAction, tableReducers } from "../table/atom.actions.js";
+import { changeTableGroupColorAction } from "../table-group/atom.actions.js";
+import { removeMemoAction$ } from "../memo/generator.actions.js";
+import { resolvePlacement } from "../../../utils/table-clipboard/placement.js";
+import { removeTableAction$ } from "../table/generator.actions.js";
+import { addColumnAction$, removeColumnAction$ } from "../table-column/generator.actions.js";
+import { getSelectTypeIds } from "./utils/selection.js";
+import { getCarriedTableIds, removeTableGroupAction$, toMoveTableGroupActions } from "../table-group/generator.actions.js";
+import { isInsideDragRect, isOverlapPosition } from "../../../utils/dragSelect.js";
+import { schemaAMLParserToSchemaJson } from "../../../utils/schema-aml-parser/index.js";
+import { schemaDBMLParserToSchemaJson } from "../../../utils/schema-dbml-parser/index.js";
+import { schemaGraphQLParserToSchemaJson } from "../../../utils/schema-graphql-parser/index.js";
+import { schemaSQLParserToSchemaJson } from "../../../utils/schema-sql-parser/index.js";
+import { toClipboardIndexes, toClipboardRelationships } from "../../../utils/table-clipboard/copy.js";
+import { getColorTargets, getColoredSelection } from "./utils/color.js";
+import { toCreateEntityActions } from "./utils/duplicate.js";
+import { findRelationshipColumn } from "./utils/findRelationshipColumn.js";
+import { viewActions$ } from "./view.generator.actions.js";
+import { cloneDeep, isEqual, omit, uniq } from "es-toolkit";
+import { isEmpty, round } from "es-toolkit/compat";
+//#region src/engine/modules/editor/generator.actions.ts
+var CENTER_BOX_SIZE = 15;
+var loadJsonAction$ = (value, { keepDictionaries = false } = {}) => function* () {
+	const flag = keepDictionaries ? { keepDictionaries } : void 0;
+	yield clearAction(flag);
+	yield loadJsonAction({
+		value,
+		...flag
+	});
+};
+var initialLoadJsonAction$ = (value) => function* () {
+	yield initialClearAction();
+	yield initialLoadJsonAction({ value });
+};
+var moveAllAction$ = (movementX, movementY, source = "document", gesture = {}) => function* (state) {
+	const { tableIds, memoIds, tableGroupIds } = getSelectTypeIds(state.editor.selectedMap);
+	const { zoomLevel } = getSceneTransform(state, source);
+	const newMovementX = movementX / zoomLevel;
+	const newMovementY = movementY / zoomLevel;
+	if (source !== "document") {
+		if (tableIds.length) yield attachActionTag(Tag.drag, viewMoveTableAction({
+			ids: tableIds,
+			movementX: newMovementX,
+			movementY: newMovementY,
+			kind: source
+		}));
+		return;
+	}
+	gesture.tableGroupIds ??= tableGroupIds;
+	gesture.tableIds ??= getCarriedTableIds(state, gesture.tableGroupIds, tableIds);
+	yield toMoveTableGroupActions(gesture.tableGroupIds, gesture.tableIds, newMovementX, newMovementY);
+	if (memoIds.length) yield attachActionTag(Tag.drag, moveMemoAction({
+		ids: memoIds,
+		movementX: newMovementX,
+		movementY: newMovementY
+	}));
+};
+var removeSelectedAction$ = () => function* () {
+	yield removeTableAction$();
+	yield removeMemoAction$();
+	yield removeTableGroupAction$();
+};
+var pasteEntitiesAction$ = (payload, pasteRound) => function* (state) {
+	yield* createEntities$(state, {
+		input: {
+			tables: payload.tables,
+			columns: payload.columns.map((column) => ({
+				...column,
+				domainId: toPastedDomainId(state, column.domainId, column.dataType)
+			})),
+			memos: payload.memos,
+			relationships: payload.relationships ?? [],
+			indexes: payload.indexes ?? []
+		},
+		offset: {
+			x: 50 * pasteRound,
+			y: 50 * pasteRound
+		},
+		escapeCollision: true
+	});
+};
+var duplicateAction$ = ({ tableIds, memoIds, offset, escapeCollision }) => function* (state) {
+	yield* createEntities$(state, {
+		input: toDuplicateInput(state, {
+			tableIds: tableIds ?? [],
+			memoIds: memoIds ?? []
+		}),
+		offset: {
+			x: round(offset.x, 4),
+			y: round(offset.y, 4)
+		},
+		escapeCollision
+	});
+};
+function* createEntities$(state, { input, offset, escapeCollision }) {
+	if (input.tables.length === 0 && input.memos.length === 0) return;
+	const { settings, doc: { tableIds, memoIds }, collections } = state;
+	const tableCollection = query(collections).collection("tableEntities");
+	const memoCollection = query(collections).collection("memoEntities");
+	const placement = resolvePlacement({
+		entities: [...input.tables.map((table) => toPlacementEntity(table, "table")), ...input.memos.map((memo) => toPlacementEntity(memo, "memo"))],
+		offset,
+		escapeCollision,
+		settings,
+		tables: tableCollection.selectByIds(tableIds),
+		memos: memoCollection.selectByIds(memoIds),
+		findSource: (sourceId) => tableCollection.selectById(sourceId) ?? memoCollection.selectById(sourceId)
+	});
+	const { actions, tableIds: newTableIds, memoIds: newMemoIds } = toCreateEntityActions(input, roundPlacement(placement));
+	yield unselectAllAction$();
+	yield actions;
+	yield selectAction({
+		...newTableIds.reduce((acc, id) => {
+			acc[id] = SelectType.table;
+			return acc;
+		}, {}),
+		...(isMemoShown(state) ? newMemoIds : []).reduce((acc, id) => {
+			acc[id] = SelectType.memo;
+			return acc;
+		}, {})
+	});
+}
+var toPlacementEntity = ({ sourceId, ui: { x, y, zIndex } }, kind) => ({
+	sourceId,
+	kind,
+	ui: {
+		x,
+		y,
+		zIndex
+	}
+});
+function roundPlacement(placement) {
+	return new Map(Array.from(placement, ([sourceId, { x, y, zIndex }]) => [sourceId, {
+		x: round(x, 4),
+		y: round(y, 4),
+		zIndex
+	}]));
+}
+function toDuplicateInput(state, { tableIds, memoIds, tableGroupIds = [] }) {
+	const { collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds);
+	const memos = query(collections).collection("memoEntities").selectByIds(memoIds);
+	const columns = tables.flatMap((table) => query(collections).collection("tableColumnEntities").selectByIds(table.columnIds));
+	const copiedTableIds = tables.map(({ id }) => id);
+	return {
+		tables: tables.map((table) => ({
+			sourceId: table.id,
+			name: table.name,
+			logicalName: table.logicalName,
+			comment: table.comment,
+			columnIds: [...table.columnIds],
+			nameDerived: table.nameDerived,
+			ui: {
+				x: table.ui.x,
+				y: table.ui.y,
+				zIndex: table.ui.zIndex,
+				widthName: table.ui.widthName,
+				widthComment: table.ui.widthComment,
+				color: table.ui.color
+			}
+		})),
+		columns: columns.map((column) => ({
+			sourceId: column.id,
+			tableId: column.tableId,
+			name: column.name,
+			comment: column.comment,
+			dataType: column.dataType,
+			default: column.default,
+			options: column.options,
+			logicalName: column.logicalName,
+			domainId: column.domainId,
+			ui: {
+				keys: column.ui.keys,
+				widthName: column.ui.widthName,
+				widthComment: column.ui.widthComment,
+				widthDataType: column.ui.widthDataType,
+				widthDefault: column.ui.widthDefault
+			}
+		})),
+		memos: memos.map((memo) => ({
+			sourceId: memo.id,
+			value: memo.value,
+			ui: {
+				x: memo.ui.x,
+				y: memo.ui.y,
+				width: memo.ui.width,
+				height: memo.ui.height,
+				zIndex: memo.ui.zIndex,
+				color: memo.ui.color
+			}
+		})),
+		relationships: toClipboardRelationships(state, copiedTableIds),
+		indexes: toClipboardIndexes(state, copiedTableIds),
+		tableGroups: query(collections).collection("tableGroupEntities").selectByIds(tableGroupIds).map((group) => ({
+			sourceId: group.id,
+			name: group.name,
+			color: group.color,
+			tableIds: tables.filter((table) => table.groupId === group.id).map(({ id }) => id),
+			ui: { ...group.ui }
+		}))
+	};
+}
+function sortGrid(state, schema, ctx) {
+	const { nameViewMode } = state.settings;
+	const copy = {
+		...state,
+		...schema,
+		settings: {
+			...schema.settings,
+			nameViewMode
+		}
+	};
+	recalculateTableWidth(copy, ctx);
+	tableReducers[ActionType.sortTable](copy, {
+		type: ActionType.sortTable,
+		payload: void 0
+	}, ctx);
+}
+function withGridPoints(json, state, ctx) {
+	const schema = parser(json);
+	sortGrid(state, schema, ctx);
+	const raw = JSON.parse(json);
+	const write = (entities, id, ui) => {
+		const entity = entities?.[id];
+		if (entity) entity.ui = {
+			...entity.ui,
+			...ui
+		};
+	};
+	const { doc, collections } = schema;
+	query(collections).collection("tableEntities").selectByIds(doc.tableIds).forEach(({ id, ui: { x, y } }) => write(raw.collections?.tableEntities, id, {
+		x,
+		y
+	}));
+	query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds).forEach(({ id, ui: { x, y, width, height } }) => write(raw.collections?.tableGroupEntities, id, {
+		x,
+		y,
+		width,
+		height
+	}));
+	return JSON.stringify(raw);
+}
+function toLayoutPoints(state, schema, { tables, memos }, layout, ctx) {
+	const { tableEntities } = schema.collections;
+	if (layout === "grid") sortGrid(state, schema, ctx);
+	const answered = new Map(typeof layout === "string" ? [] : layout.map(({ id, x, y }) => [id, {
+		x,
+		y
+	}]));
+	return new Map([...tables.map(({ sourceId }) => {
+		const { x, y } = tableEntities[sourceId].ui;
+		return [sourceId, answered.get(sourceId) ?? {
+			x,
+			y
+		}];
+	}), ...memos.map(({ sourceId, ui: { x, y } }) => [sourceId, {
+		x,
+		y
+	}])]);
+}
+function toLayoutGroupRects({ tableGroups = [] }, layout, points, sizes) {
+	if (layout === "file") return tableGroups.map(({ ui }) => ui);
+	return tableGroups.flatMap(({ tableIds }) => {
+		const rects = tableIds.flatMap((id) => {
+			const point = points.get(id);
+			const size = sizes.get(id);
+			return point && size ? [{
+				...point,
+				...size
+			}] : [];
+		});
+		return rects.length ? [padRect(rects.reduce(unionRect))] : [];
+	});
+}
+function toAppendOrigin(state) {
+	const hiddenGroups = isTableGroupShown(state) ? [] : [...getTableGroupRects(state).values()];
+	const hiddenMemos = isMemoShown(state) ? [] : query(state.collections).collection("memoEntities").selectByIds(state.doc.memoIds).map(getMemoRect);
+	const hidden = [...hiddenGroups, ...hiddenMemos];
+	const content = [getContentRect(state), ...hidden].filter((rect) => rect !== null).reduce((box, rect) => box ? unionRect(box, rect) : rect, null);
+	return content ? {
+		x: content.x,
+		y: content.y + content.height + 80
+	} : {
+		x: 50,
+		y: 50
+	};
+}
+function toSchemaAppend(state, json, layout, ctx) {
+	let schema;
+	try {
+		schema = parser(json);
+	} catch {
+		return null;
+	}
+	const { doc, collections } = schema;
+	const read = {
+		...state,
+		doc,
+		collections
+	};
+	const copied = toDuplicateInput(read, doc);
+	if (!copied.tables.length && !copied.memos.length) return null;
+	const input = {
+		...copied,
+		columns: copied.columns.map((column) => ({
+			...column,
+			domainId: ""
+		}))
+	};
+	const points = toLayoutPoints(state, schema, input, layout, ctx);
+	const appended = {
+		...read,
+		doc: {
+			...doc,
+			domainIds: []
+		}
+	};
+	const sizes = new Map(query(collections).collection("tableEntities").selectByIds(doc.tableIds).map((table) => [table.id, measureTableSize(table, appended, ctx.toWidth)]));
+	let minX = Infinity;
+	let minY = Infinity;
+	for (const { x, y } of [...points.values(), ...toLayoutGroupRects(input, layout, points, sizes)]) {
+		minX = Math.min(minX, x);
+		minY = Math.min(minY, y);
+	}
+	const origin = toAppendOrigin(state);
+	const baseZIndex = nextZIndex(query(state.collections).collection("tableEntities").selectByIds(state.doc.tableIds), query(state.collections).collection("memoEntities").selectByIds(state.doc.memoIds));
+	const stacked = [...input.tables, ...input.memos].sort((a, b) => a.ui.zIndex - b.ui.zIndex);
+	const placement = /* @__PURE__ */ new Map();
+	stacked.forEach(({ sourceId }, index) => {
+		const point = points.get(sourceId);
+		placement.set(sourceId, {
+			x: round(origin.x + point.x - minX, 4),
+			y: round(origin.y + point.y - minY, 4),
+			zIndex: baseZIndex + index
+		});
+	});
+	const tableRects = new Map(query(collections).collection("tableEntities").selectByIds(doc.tableIds).map((table) => {
+		const { x, y } = placement.get(table.id);
+		return [table.id, {
+			x,
+			y,
+			...sizes.get(table.id)
+		}];
+	}));
+	const memoRects = query(collections).collection("memoEntities").selectByIds(doc.memoIds).map((memo) => getMemoRect({
+		...memo,
+		ui: {
+			...memo.ui,
+			...placement.get(memo.id)
+		}
+	}));
+	const tableGroups = toAppendTableGroups(state, input, layout, tableRects, {
+		x: origin.x - minX,
+		y: origin.y - minY
+	});
+	return {
+		...toCreateEntityActions({
+			...input,
+			tableGroups
+		}, placement, { valuesOnly: true }),
+		rect: [
+			...tableRects.values(),
+			...memoRects,
+			...tableGroups.map(({ ui: { x, y, width, height } }) => ({
+				x,
+				y,
+				width,
+				height
+			}))
+		].reduce(unionRect)
+	};
+}
+function toAppendTableGroups(state, { tableGroups = [] }, layout, tableRects, offset) {
+	const baseZIndex = nextTableGroupZIndex(query(state.collections).collection("tableGroupEntities").selectByIds(state.doc.tableGroupIds));
+	return [...tableGroups].sort((a, b) => a.ui.zIndex - b.ui.zIndex).map((group, index) => {
+		const members = group.tableIds.map((id) => tableRects.get(id)).filter((rect) => Boolean(rect));
+		const { x, y, width, height } = layout === "file" || !members.length ? {
+			...group.ui,
+			x: round(group.ui.x + offset.x, 4),
+			y: round(group.ui.y + offset.y, 4)
+		} : padRect(members.reduce(unionRect));
+		return {
+			...group,
+			ui: {
+				x,
+				y,
+				width,
+				height,
+				zIndex: baseZIndex + index
+			}
+		};
+	});
+}
+var appendSchemaJsonAction$ = (json, layout = "file") => function* (state, ctx) {
+	const append = toSchemaAppend(state, json, layout, ctx);
+	if (append) yield append.actions;
+};
+var appendSchemaAction$ = (type, value) => function* (state, ctx) {
+	yield appendSchemaJsonAction$(toSchemaImportJson(type, value, state, ctx), "grid");
+};
+var dragSelectAction$ = (dragRect, source = "document") => function* (state) {
+	const { collections } = state;
+	const { tableIds, memoIds } = getVisibleIds(state, source);
+	const selectedMap = {
+		...query(collections).collection("tableEntities").selectByIds(tableIds).reduce((acc, table) => {
+			const rect = getTableRect(state, table, source);
+			const x = rect.x + rect.width / 2 - CENTER_BOX_SIZE;
+			const y = rect.y + rect.height / 2 - CENTER_BOX_SIZE;
+			if (isOverlapPosition(dragRect, {
+				x,
+				y,
+				w: CENTER_BOX_SIZE,
+				h: CENTER_BOX_SIZE
+			})) acc[table.id] = SelectType.table;
+			return acc;
+		}, {}),
+		...query(collections).collection("memoEntities").selectByIds(memoIds).reduce((acc, memo) => {
+			const width = calcMemoWidth(memo);
+			const height = calcMemoHeight(memo);
+			const x = memo.ui.x + width / 2 - CENTER_BOX_SIZE;
+			const y = memo.ui.y + height / 2 - CENTER_BOX_SIZE;
+			if (isOverlapPosition(dragRect, {
+				x,
+				y,
+				w: CENTER_BOX_SIZE,
+				h: CENTER_BOX_SIZE
+			})) acc[memo.id] = SelectType.memo;
+			return acc;
+		}, {}),
+		...takenTableGroups(state, dragRect, source)
+	};
+	yield unselectAllAction$();
+	if (!isEmpty(selectedMap)) yield selectAction(selectedMap);
+};
+function takenTableGroups(state, dragRect, source) {
+	if (source !== "document" || !isTableGroupShown(state)) return {};
+	const taken = {};
+	getTableGroupRects(state).forEach(({ x, y, width, height }, id) => {
+		if (isInsideDragRect(dragRect, {
+			x,
+			y,
+			w: width,
+			h: height
+		})) taken[id] = SelectType.tableGroup;
+	});
+	return taken;
+}
+var unselectAllAction$ = () => function* () {
+	yield unselectAllAction();
+	yield focusTableEndAction();
+};
+var focusMoveTableAction$ = (moveKey, shiftKey) => function* (state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return;
+	if (moveKey === MoveKey.Tab && !shiftKey && (isTableFocusType(focusTable.focusType) && isLastTable(state) && !isColumns(state) || !isTableFocusType(focusTable.focusType) && isLastColumn(state) && isLastRowColumn(state))) yield addColumnAction$(focusTable.tableId);
+	else yield focusMoveTableAction({
+		moveKey,
+		shiftKey
+	});
+};
+var drawStartRelationshipAction$ = (relationshipType) => function* ({ editor }) {
+	if (editor.drawRelationship?.relationshipType === relationshipType) yield drawEndRelationshipAction();
+	else yield drawStartRelationshipAction({ relationshipType });
+};
+var drawStartAddRelationshipAction$ = (tableId) => function* (state) {
+	const { collections } = state;
+	const table = query(collections).collection("tableEntities").selectById(tableId);
+	if (!table) return;
+	if (!query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).some((column) => bHas(column.options, ColumnOption.primaryKey))) {
+		const columnId = uuid25();
+		yield addColumnAction({
+			tableId,
+			id: columnId
+		});
+		yield changeColumnPrimaryKeyAction({
+			tableId,
+			id: columnId,
+			value: true
+		});
+		yield focusColumnAction({
+			tableId,
+			columnId,
+			focusType: getFirstColumnType(state),
+			$mod: false,
+			shiftKey: false
+		});
+	}
+	yield drawStartAddRelationshipAction({ tableId });
+};
+var changeColorAllAction$ = (color) => function* (state) {
+	const { tables, memos, tableGroups } = getColorTargets(state);
+	const target = color.toLowerCase();
+	yield tables.filter((table) => table.ui.color.toLowerCase() !== target).map((table) => changeTableColorAction({
+		id: table.id,
+		color,
+		prevColor: table.ui.color
+	}));
+	yield memos.filter((memo) => memo.ui.color.toLowerCase() !== target).map((memo) => changeMemoColorAction({
+		id: memo.id,
+		color,
+		prevColor: memo.ui.color
+	}));
+	yield tableGroups.filter((group) => group.color.toLowerCase() !== target).map((group) => changeTableGroupColorAction({
+		id: group.id,
+		color,
+		prevColor: group.color
+	}));
+};
+var removeColorAllAction$ = () => function* (state) {
+	const { tables, memos, tableGroups } = getColoredSelection(state);
+	yield tables.map((table) => changeTableColorAction({
+		id: table.id,
+		color: "",
+		prevColor: table.ui.color
+	}));
+	yield memos.map((memo) => changeMemoColorAction({
+		id: memo.id,
+		color: "",
+		prevColor: memo.ui.color
+	}));
+	yield tableGroups.map((group) => changeTableGroupColorAction({
+		id: group.id,
+		color: "",
+		prevColor: group.color
+	}));
+};
+var IMPORT_OMIT_SETTINGS = [
+	"originX",
+	"originY",
+	"zoomLevel"
+];
+function withImportSettings(schema, settings) {
+	const kept = omit(cloneDeep(settings), IMPORT_OMIT_SETTINGS);
+	const { originX, originY, zoomLevel } = schema.settings;
+	schema.settings = {
+		...schema.settings,
+		...kept,
+		lockedValues: {
+			...kept.lockedValues,
+			originX,
+			originY,
+			zoomLevel
+		}
+	};
+}
+function toSchemaImportJson(type, value, { settings }, ctx) {
+	const prepare = (schema) => {
+		withImportSettings(schema, settings);
+		return schema;
+	};
+	switch (type) {
+		case "sql": return schemaSQLParserToSchemaJson(value, ctx, prepare, settings.database);
+		case "graphql": return schemaGraphQLParserToSchemaJson(value, ctx, prepare);
+		case "dbml": return schemaDBMLParserToSchemaJson(value, ctx, prepare);
+		case "aml": return schemaAMLParserToSchemaJson(value, ctx, prepare);
+	}
+}
+var loadSchemaAction$ = (type, value) => function* (state, ctx) {
+	yield loadJsonAction$(withGridPoints(toSchemaImportJson(type, value, state, ctx), state, ctx), { keepDictionaries: true });
+};
+var loadSchemaSQLAction$ = (value) => loadSchemaAction$("sql", value);
+var loadSchemaGraphQLAction$ = (value) => loadSchemaAction$("graphql", value);
+var loadSchemaDBMLAction$ = (value) => loadSchemaAction$("dbml", value);
+var loadSchemaAMLAction$ = (value) => loadSchemaAction$("aml", value);
+var dragstartColumnAction$ = () => function* (state) {
+	const { focusTable } = state.editor;
+	const columnIds = getFocusedColumnIds(state);
+	if (!focusTable || columnIds.length === 0) return;
+	yield dragstartColumnAction({
+		tableId: focusTable.tableId,
+		columnIds
+	});
+};
+function moveColumnsToEnd(tableId, order, columnIds) {
+	const ids = [...order];
+	const actions = [];
+	for (const id of columnIds) {
+		const index = ids.indexOf(id);
+		if (index === -1) return [];
+		const targetId = ids[ids.length - 1];
+		if (id === targetId) continue;
+		ids.splice(index, 1);
+		ids.push(id);
+		actions.push(moveColumnAction({
+			tableId,
+			id,
+			targetId
+		}));
+	}
+	return isEqual(ids, order) ? [] : actions;
+}
+var dragoverColumnAction$ = (targetId, targetTableId) => function* ({ editor: { draggableColumn }, collections }) {
+	if (!draggableColumn || draggableColumn.columnIds.length === 0) return;
+	const { tableId, columnIds } = draggableColumn;
+	const tableCollection = query(collections).collection("tableEntities");
+	const table = tableCollection.selectById(tableId);
+	if (!table) return;
+	if (targetTableId === tableId) {
+		const index = table.columnIds.indexOf(columnIds[0]);
+		if (index === -1) return;
+		if (targetId === null) {
+			yield moveColumnsToEnd(tableId, table.columnIds, columnIds);
+			return;
+		}
+		const targetIndex = table.columnIds.indexOf(targetId);
+		if (targetIndex === -1) return;
+		const actions = columnIds.map((id) => moveColumnAction({
+			tableId,
+			id,
+			targetId
+		}));
+		if (index < targetIndex) actions.reverse();
+		yield actions;
+		return;
+	}
+	if (!tableCollection.selectById(targetTableId)) return;
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(columnIds);
+	if (columns.length === 0) return;
+	yield removeColumnAction$(tableId, columnIds);
+	const newColumnIds = columns.map(() => uuid25());
+	for (let i = 0; i < columns.length; i++) {
+		const column = columns[i];
+		const newColumnId = newColumnIds[i];
+		const payload = {
+			id: newColumnId,
+			tableId: targetTableId
+		};
+		yield [
+			addColumnAction(payload),
+			changeColumnNameAction({
+				...payload,
+				value: column.name
+			}),
+			changeColumnDataTypeAction({
+				...payload,
+				value: column.dataType
+			}),
+			changeColumnDefaultAction({
+				...payload,
+				value: column.default
+			}),
+			changeColumnCommentAction({
+				...payload,
+				value: column.comment
+			}),
+			changeColumnPrimaryKeyAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.primaryKey)
+			}),
+			changeColumnNotNullAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.notNull)
+			}),
+			changeColumnUniqueAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.unique)
+			}),
+			changeColumnAutoIncrementAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.autoIncrement)
+			}),
+			changeColumnLogicalNameAction({
+				...payload,
+				value: column.logicalName
+			}),
+			changeColumnDomainAction({
+				...payload,
+				value: column.domainId
+			}),
+			changeColumnNameDerivedAction({
+				...payload,
+				value: bHas(column.options, ColumnOption.nameDerived)
+			}),
+			...targetId === null ? [] : [moveColumnAction({
+				...payload,
+				targetId
+			})],
+			focusColumnAction({
+				tableId: targetTableId,
+				columnId: newColumnId,
+				focusType: FocusType.columnName,
+				$mod: true,
+				shiftKey: false
+			})
+		];
+	}
+	yield dragstartColumnAction({
+		tableId: targetTableId,
+		columnIds: newColumnIds
+	});
+};
+var columnKeyHoverStartAction$ = (columnId) => function* (state) {
+	const { columnIds, relationshipIds } = findRelationshipColumn([{
+		columnId,
+		relationshipIds: []
+	}], state).reduce((acc, { columnId, relationshipIds }) => {
+		acc.columnIds.push(columnId);
+		acc.relationshipIds.push(...relationshipIds);
+		return acc;
+	}, {
+		columnIds: [],
+		relationshipIds: []
+	});
+	yield hoverColumnMapAction({ columnIds: uniq(columnIds) });
+	yield hoverRelationshipMapAction({ relationshipIds: uniq(relationshipIds) });
+};
+var columnKeyHoverEndAction$ = () => function* () {
+	yield hoverColumnMapAction({ columnIds: [] });
+	yield hoverRelationshipMapAction({ relationshipIds: [] });
+};
+var actions$ = {
+	loadJsonAction$,
+	initialLoadJsonAction$,
+	moveAllAction$,
+	removeSelectedAction$,
+	pasteEntitiesAction$,
+	duplicateAction$,
+	dragSelectAction$,
+	unselectAllAction$,
+	focusMoveTableAction$,
+	drawStartRelationshipAction$,
+	drawStartAddRelationshipAction$,
+	changeColorAllAction$,
+	removeColorAllAction$,
+	loadSchemaSQLAction$,
+	loadSchemaGraphQLAction$,
+	loadSchemaDBMLAction$,
+	loadSchemaAMLAction$,
+	appendSchemaAction$,
+	appendSchemaJsonAction$,
+	dragstartColumnAction$,
+	dragoverColumnAction$,
+	columnKeyHoverStartAction$,
+	columnKeyHoverEndAction$,
+	...viewActions$
+};
+//#endregion
+export { actions$, appendSchemaAction$, appendSchemaJsonAction$, changeColorAllAction$, columnKeyHoverEndAction$, columnKeyHoverStartAction$, dragSelectAction$, dragoverColumnAction$, dragstartColumnAction$, drawStartAddRelationshipAction$, drawStartRelationshipAction$, duplicateAction$, focusMoveTableAction$, initialLoadJsonAction$, loadJsonAction$, loadSchemaAMLAction$, loadSchemaAction$, loadSchemaDBMLAction$, loadSchemaGraphQLAction$, loadSchemaSQLAction$, moveAllAction$, pasteEntitiesAction$, removeColorAllAction$, removeSelectedAction$, toSchemaAppend, toSchemaImportJson, unselectAllAction$, withGridPoints, withImportSettings };