@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/engine/modules/editor/utils/focus.js

@@ -0,0 +1,276 @@
+import { query } from "../../../../erd-editor-schema/dist/query/index.js";
+import { arrayHas } from "../../../../utils/arrayHas.js";
+import { isHighLevelTable } from "../../../../utils/validation.js";
+import { FocusType, MoveKey } from "../state.js";
+import { getColumnFocusTypes, getTableFocusTypes, toShownFocusType } from "./nameView.js";
+import { appendSelectColumns } from "./selectRangeColumn.js";
+//#region src/engine/modules/editor/utils/focus.ts
+var TableFocusTypes = [
+	FocusType.tableName,
+	FocusType.tableLogicalName,
+	FocusType.tableComment
+];
+function getColumnTypes({ settings }) {
+	return getColumnFocusTypes(settings);
+}
+function indexOfFocus({ settings }, types, focusType) {
+	return types.indexOf(toShownFocusType(settings, types, focusType) ?? focusType);
+}
+function isColumns({ collections, editor: { focusTable } }) {
+	if (!focusTable) return false;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	return Boolean(table?.columnIds.length);
+}
+function isLastColumn(state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return true;
+	const columnTypes = getColumnTypes(state);
+	return indexOfFocus(state, columnTypes, focusTable.focusType) === columnTypes.length - 1;
+}
+function isFirstColumn(state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return true;
+	return indexOfFocus(state, getColumnTypes(state), focusTable.focusType) === 0;
+}
+function isLastRowColumn({ collections, editor: { focusTable } }) {
+	if (!focusTable?.columnId) return true;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return true;
+	return table.columnIds.indexOf(focusTable.columnId) === table.columnIds.length - 1;
+}
+function isFirstRowColumn({ collections, editor: { focusTable } }) {
+	if (!focusTable?.columnId) return true;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return true;
+	return table.columnIds.indexOf(focusTable.columnId) === 0;
+}
+function getLastColumnType(state) {
+	const columnTypes = getColumnTypes(state);
+	return columnTypes[columnTypes.length - 1];
+}
+function getFirstColumnType(state) {
+	return getColumnTypes(state)[0];
+}
+function getNextRightColumnType(state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return FocusType.columnName;
+	const columnTypes = getColumnTypes(state);
+	const index = indexOfFocus(state, columnTypes, focusTable.focusType);
+	return isLastColumn(state) ? columnTypes[0] : columnTypes[index + 1];
+}
+function getNextLeftColumnType(state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return FocusType.columnName;
+	const columnTypes = getColumnTypes(state);
+	const index = indexOfFocus(state, columnTypes, focusTable.focusType);
+	return isFirstColumn(state) ? columnTypes[columnTypes.length - 1] : columnTypes[index - 1];
+}
+function getRemoveFirstColumnId(state, columnIds) {
+	const { collections, editor: { focusTable } } = state;
+	if (!focusTable?.columnId) return null;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return null;
+	const columnIndex = table.columnIds.indexOf(focusTable.columnId);
+	if (columnIndex <= 0) return null;
+	let columnId = null;
+	for (let i = columnIndex; i >= 0; i--) {
+		const currentColumnId = table.columnIds[i];
+		if (!columnIds.includes(currentColumnId)) {
+			columnId = currentColumnId;
+			break;
+		}
+	}
+	return columnId;
+}
+function getFocusedColumnIds({ editor: { focusTable }, collections }) {
+	if (!focusTable?.columnId) return [];
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return [];
+	const { columnId } = focusTable;
+	const selected = focusTable.selectColumnIds.filter(arrayHas(table.columnIds));
+	return selected.length > 1 && selected.includes(columnId) ? selected : [columnId];
+}
+function getRemovableColumns({ doc: { tableIds, memoIds, tableGroupIds }, editor: { focusTable, selectedMap }, settings: { zoomLevel }, collections }) {
+	if (!focusTable?.selectColumnIds.length || isHighLevelTable(zoomLevel)) return null;
+	const selectedIds = Object.keys(selectedMap).filter(arrayHas([
+		...tableIds,
+		...memoIds,
+		...tableGroupIds
+	]));
+	if (selectedIds.length !== 1 || selectedIds[0] !== focusTable.tableId) return null;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return null;
+	const columnIds = focusTable.selectColumnIds.filter(arrayHas(table.columnIds));
+	return columnIds.length ? {
+		tableId: focusTable.tableId,
+		columnIds
+	} : null;
+}
+function getTableTypes({ settings }) {
+	return getTableFocusTypes(settings);
+}
+function getFirstTableType(state) {
+	return getTableTypes(state)[0];
+}
+function getLastTableType(state) {
+	const tableTypes = getTableTypes(state);
+	return tableTypes[tableTypes.length - 1];
+}
+function isLastTable(state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return true;
+	const tableTypes = getTableTypes(state);
+	return indexOfFocus(state, tableTypes, focusTable.focusType) === tableTypes.length - 1;
+}
+function isFirstTable(state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return true;
+	return indexOfFocus(state, getTableTypes(state), focusTable.focusType) === 0;
+}
+var isTableFocusType = arrayHas(TableFocusTypes);
+function getNextRightTableType(state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return FocusType.tableName;
+	const tableTypes = getTableTypes(state);
+	const index = indexOfFocus(state, tableTypes, focusTable.focusType);
+	return isLastTable(state) ? tableTypes[0] : tableTypes[index + 1];
+}
+function getNextLeftTableType(state) {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return FocusType.tableName;
+	const tableTypes = getTableTypes(state);
+	const index = indexOfFocus(state, tableTypes, focusTable.focusType);
+	return isFirstTable(state) ? tableTypes[tableTypes.length - 1] : tableTypes[index - 1];
+}
+function arrowUp(state, payload) {
+	const { collections, editor: { focusTable } } = state;
+	if (!focusTable) return;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return;
+	if (isTableFocusType(focusTable.focusType)) {
+		if (isColumns(state)) {
+			const columnId = table.columnIds[table.columnIds.length - 1];
+			focusTable.focusType = getLastColumnType(state);
+			focusTable.columnId = columnId;
+			focusTable.prevSelectColumnId = columnId;
+			focusTable.selectColumnIds = [columnId];
+		}
+	} else if (isFirstRowColumn(state)) {
+		focusTable.focusType = getFirstTableType(state);
+		focusTable.columnId = null;
+		focusTable.prevSelectColumnId = null;
+		focusTable.selectColumnIds = [];
+	} else if (focusTable.columnId) {
+		const index = table.columnIds.indexOf(focusTable.columnId);
+		const columnId = table.columnIds[index - 1];
+		focusTable.columnId = columnId;
+		focusTable.prevSelectColumnId = columnId;
+		if (payload.shiftKey && payload.moveKey !== MoveKey.Tab) focusTable.selectColumnIds = appendSelectColumns(focusTable.selectColumnIds, columnId);
+		else focusTable.selectColumnIds = [columnId];
+	}
+}
+function arrowDown(state, payload) {
+	const { collections, editor: { focusTable } } = state;
+	if (!focusTable) return;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return;
+	if (isTableFocusType(focusTable.focusType)) {
+		if (isColumns(state)) {
+			const columnId = table.columnIds[0];
+			focusTable.focusType = getFirstColumnType(state);
+			focusTable.columnId = columnId;
+			focusTable.prevSelectColumnId = columnId;
+			focusTable.selectColumnIds = [columnId];
+		}
+	} else if (isLastRowColumn(state)) {
+		focusTable.focusType = getFirstTableType(state);
+		focusTable.columnId = null;
+		focusTable.prevSelectColumnId = null;
+		focusTable.selectColumnIds = [];
+	} else if (focusTable.columnId) {
+		const index = table.columnIds.indexOf(focusTable.columnId);
+		const columnId = table.columnIds[index + 1];
+		focusTable.columnId = columnId;
+		focusTable.prevSelectColumnId = columnId;
+		if (payload.shiftKey && payload.moveKey !== MoveKey.Tab) focusTable.selectColumnIds = appendSelectColumns(focusTable.selectColumnIds, columnId);
+		else focusTable.selectColumnIds = [columnId];
+	}
+}
+function arrowLeft(state, payload) {
+	const { collections, editor: { focusTable } } = state;
+	if (!focusTable) return;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return;
+	if (isTableFocusType(focusTable.focusType)) {
+		if (isFirstTable(state)) {
+			if (isColumns(state)) {
+				const columnId = table.columnIds[table.columnIds.length - 1];
+				focusTable.focusType = getLastColumnType(state);
+				focusTable.columnId = columnId;
+				focusTable.prevSelectColumnId = columnId;
+				focusTable.selectColumnIds = [columnId];
+			} else focusTable.focusType = getNextLeftTableType(state);
+		} else focusTable.focusType = getNextLeftTableType(state);
+	} else if (isFirstColumn(state)) {
+		if (isFirstRowColumn(state)) {
+			focusTable.focusType = getLastTableType(state);
+			focusTable.columnId = null;
+			focusTable.prevSelectColumnId = null;
+			focusTable.selectColumnIds = [];
+		} else if (focusTable.columnId) {
+			const index = table.columnIds.indexOf(focusTable.columnId);
+			const columnId = table.columnIds[index - 1];
+			focusTable.focusType = getLastColumnType(state);
+			focusTable.columnId = columnId;
+			focusTable.prevSelectColumnId = columnId;
+			if (payload.shiftKey && payload.moveKey !== MoveKey.Tab) focusTable.selectColumnIds = appendSelectColumns(focusTable.selectColumnIds, columnId);
+			else focusTable.selectColumnIds = [columnId];
+		}
+	} else {
+		focusTable.focusType = getNextLeftColumnType(state);
+		if (!payload.shiftKey && focusTable.columnId) {
+			focusTable.prevSelectColumnId = focusTable.columnId;
+			focusTable.selectColumnIds = [focusTable.columnId];
+		}
+	}
+}
+function arrowRight(state, payload) {
+	const { collections, editor: { focusTable } } = state;
+	if (!focusTable) return;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return;
+	if (isTableFocusType(focusTable.focusType)) {
+		if (isLastTable(state)) {
+			if (isColumns(state)) {
+				const columnId = table.columnIds[0];
+				focusTable.focusType = getFirstColumnType(state);
+				focusTable.columnId = columnId;
+				focusTable.prevSelectColumnId = columnId;
+				focusTable.selectColumnIds = [columnId];
+			} else focusTable.focusType = getNextRightTableType(state);
+		} else focusTable.focusType = getNextRightTableType(state);
+	} else if (isLastColumn(state)) {
+		if (isLastRowColumn(state)) {
+			focusTable.focusType = getFirstTableType(state);
+			focusTable.columnId = null;
+			focusTable.prevSelectColumnId = null;
+			focusTable.selectColumnIds = [];
+		} else if (focusTable.columnId) {
+			const index = table.columnIds.indexOf(focusTable.columnId);
+			const columnId = table.columnIds[index + 1];
+			focusTable.focusType = getFirstColumnType(state);
+			focusTable.columnId = columnId;
+			focusTable.prevSelectColumnId = columnId;
+			if (payload.shiftKey && payload.moveKey !== MoveKey.Tab) focusTable.selectColumnIds = appendSelectColumns(focusTable.selectColumnIds, columnId);
+			else focusTable.selectColumnIds = [columnId];
+		}
+	} else {
+		focusTable.focusType = getNextRightColumnType(state);
+		if (!payload.shiftKey && focusTable.columnId) {
+			focusTable.prevSelectColumnId = focusTable.columnId;
+			focusTable.selectColumnIds = [focusTable.columnId];
+		}
+	}
+}
+//#endregion
+export { arrowDown, arrowLeft, arrowRight, arrowUp, getFirstColumnType, getFocusedColumnIds, getRemovableColumns, getRemoveFirstColumnId, isColumns, isLastColumn, isLastRowColumn, isLastTable, isTableFocusType };

package/dist/engine/modules/editor/utils/nameView.js

@@ -0,0 +1,113 @@
+import { ColumnType, NameViewMode, Show } from "../../../../constants/schema.js";
+import { getLiveDomainName } from "../../dictionary/membership.js";
+import { FocusType, ViewKind } from "../state.js";
+import { bHas } from "../../../../utils/bit.js";
+//#region src/engine/modules/editor/utils/nameView.ts
+var sceneNameSettings = (settings, source = "document") => source === "document" ? settings : {
+	nameViewMode: settings.nameViewMode,
+	show: 0
+};
+var isLogicalNameView = ({ nameViewMode }) => nameViewMode === NameViewMode.logical;
+var isBothNameView = ({ nameViewMode }) => nameViewMode === NameViewMode.both;
+var drawsNameForLogicalName = (settings, { logicalName }) => isLogicalNameView(settings) && !logicalName.trim();
+function toNameLabel(settings, { name, logicalName }) {
+	const logical = logicalName.trim() ? logicalName : "";
+	if (isLogicalNameView(settings)) return logical ? {
+		text: logical,
+		after: "",
+		standIn: false
+	} : {
+		text: name,
+		after: "",
+		standIn: name.trim() !== ""
+	};
+	if (isBothNameView(settings) && logical) return {
+		text: logical,
+		after: name.trim() ? name : "",
+		standIn: false
+	};
+	return {
+		text: name,
+		after: "",
+		standIn: false
+	};
+}
+var nameLabelText = ({ text, after }) => after ? `${text} (${after})` : text;
+var isDomainInTypeCell = (settings) => isLogicalNameView(settings) && !bHas(settings.show, Show.columnDomain);
+var drawsDomainInTypeCell = (state, column, source = "document") => isDomainInTypeCell(sceneNameSettings(state.settings, source)) && getLiveDomainName(state, column.domainId) !== "";
+function getTableFocusTypes(settings) {
+	const names = isLogicalNameView(settings) ? [FocusType.tableLogicalName] : isBothNameView(settings) ? [FocusType.tableLogicalName, FocusType.tableName] : [FocusType.tableName];
+	return bHas(settings.show, Show.tableComment) ? [...names, FocusType.tableComment] : names;
+}
+var shownBy = (bit) => ({ show }) => bHas(show, bit);
+var ColumnTypeShown = {
+	[ColumnType.columnName]: () => true,
+	[ColumnType.columnLogicalName]: isBothNameView,
+	[ColumnType.columnDataType]: shownBy(Show.columnDataType),
+	[ColumnType.columnDomain]: shownBy(Show.columnDomain),
+	[ColumnType.columnNotNull]: shownBy(Show.columnNotNull),
+	[ColumnType.columnUnique]: shownBy(Show.columnUnique),
+	[ColumnType.columnAutoIncrement]: shownBy(Show.columnAutoIncrement),
+	[ColumnType.columnDefault]: shownBy(Show.columnDefault),
+	[ColumnType.columnComment]: shownBy(Show.columnComment)
+};
+var COLUMN_FOCUS_TYPES = {
+	[ColumnType.columnName]: FocusType.columnName,
+	[ColumnType.columnLogicalName]: FocusType.columnLogicalName,
+	[ColumnType.columnDataType]: FocusType.columnDataType,
+	[ColumnType.columnDomain]: FocusType.columnDomain,
+	[ColumnType.columnNotNull]: FocusType.columnNotNull,
+	[ColumnType.columnUnique]: FocusType.columnUnique,
+	[ColumnType.columnAutoIncrement]: FocusType.columnAutoIncrement,
+	[ColumnType.columnDefault]: FocusType.columnDefault,
+	[ColumnType.columnComment]: FocusType.columnComment
+};
+function toNameViewFocusType(settings, focusType) {
+	if (isLogicalNameView(settings)) {
+		if (focusType === FocusType.tableName) return FocusType.tableLogicalName;
+		if (focusType === FocusType.columnName) return FocusType.columnLogicalName;
+	}
+	if (focusType === FocusType.columnDataType && isDomainInTypeCell(settings)) return FocusType.columnDomain;
+	return focusType;
+}
+function getColumnFocusTypes(settings) {
+	const types = [];
+	for (const columnType of settings.columnOrder) {
+		const focusType = COLUMN_FOCUS_TYPES[columnType];
+		if (focusType && ColumnTypeShown[columnType](settings)) types.push(toNameViewFocusType(settings, focusType));
+	}
+	return types;
+}
+function getViewColumnTypes(settings) {
+	return isBothNameView(settings) ? [
+		ColumnType.columnLogicalName,
+		ColumnType.columnName,
+		ColumnType.columnDomain,
+		ColumnType.columnDataType
+	] : [ColumnType.columnName, ColumnType.columnDataType];
+}
+function getViewColumnFocusTypes(settings) {
+	const shown = sceneNameSettings(settings, ViewKind.flow);
+	return getViewColumnTypes(settings).map((columnType) => toNameViewFocusType(shown, COLUMN_FOCUS_TYPES[columnType]));
+}
+var PHYSICAL_FOCUS_TYPES = {
+	[FocusType.tableLogicalName]: FocusType.tableName,
+	[FocusType.columnLogicalName]: FocusType.columnName,
+	[FocusType.columnDomain]: FocusType.columnDataType
+};
+function toShownFocusType(settings, types, focusType) {
+	if (types.includes(focusType)) return focusType;
+	const shown = toNameViewFocusType(settings, PHYSICAL_FOCUS_TYPES[focusType] ?? focusType);
+	return types.includes(shown) ? shown : null;
+}
+function keepFocusShown(state) {
+	const { focusTable } = state.editor;
+	if (!focusTable) return;
+	const types = focusTable.columnId ? getColumnFocusTypes(state.settings) : getTableFocusTypes(state.settings);
+	const shown = toShownFocusType(state.settings, types, focusTable.focusType);
+	if (!shown || shown === focusTable.focusType) return;
+	focusTable.focusType = shown;
+	focusTable.edit = false;
+}
+//#endregion
+export { ColumnTypeShown, drawsDomainInTypeCell, drawsNameForLogicalName, getColumnFocusTypes, getTableFocusTypes, getViewColumnFocusTypes, getViewColumnTypes, isBothNameView, isDomainInTypeCell, isLogicalNameView, keepFocusShown, nameLabelText, sceneNameSettings, toNameLabel, toNameViewFocusType, toShownFocusType };

package/dist/engine/modules/editor/utils/releaseHidden.js

@@ -0,0 +1,25 @@
+import { Show } from "../../../../constants/schema.js";
+import { SelectType } from "../state.js";
+import { bHas } from "../../../../utils/bit.js";
+//#region src/engine/modules/editor/utils/releaseHidden.ts
+var dropSelected = (state, type) => {
+	Object.entries(state.editor.selectedMap).forEach(([id, selected]) => {
+		if (selected === type) Reflect.deleteProperty(state.editor.selectedMap, id);
+	});
+};
+function releaseTableGroups(state) {
+	dropSelected(state, SelectType.tableGroup);
+	state.editor.drawTableGroup = false;
+	state.editor.editTableGroupId = null;
+}
+function releaseMemos(state) {
+	dropSelected(state, SelectType.memo);
+	state.editor.editMemoId = null;
+}
+function releaseHidden(state) {
+	const { show } = state.settings;
+	if (bHas(show, Show.hideTableGroup)) releaseTableGroups(state);
+	if (bHas(show, Show.hideMemo)) releaseMemos(state);
+}
+//#endregion
+export { releaseHidden, releaseMemos, releaseTableGroups };

package/dist/engine/modules/editor/utils/selectRangeColumn.js

@@ -0,0 +1,18 @@
+import { safeRange } from "../../../../utils/index.js";
+import { uniq } from "es-toolkit";
+//#region src/engine/modules/editor/utils/selectRangeColumn.ts
+function appendSelectColumns(columnIds, columnId) {
+	return uniq([...columnIds, columnId]);
+}
+function selectRangeColumns(columnIds, fromColumnId, toColumnId) {
+	if (!fromColumnId || fromColumnId === toColumnId) return [toColumnId];
+	const fromIndex = columnIds.indexOf(fromColumnId);
+	const toIndex = columnIds.indexOf(toColumnId);
+	if (fromIndex === -1) return [toColumnId];
+	return safeRange(fromIndex, toIndex).map((index) => columnIds[index]);
+}
+function appendSelectRangeColumns(columnIds, selectColumnIds, fromColumnId, toColumnId) {
+	return uniq([...selectColumnIds, ...selectRangeColumns(columnIds, fromColumnId, toColumnId)]);
+}
+//#endregion
+export { appendSelectColumns, appendSelectRangeColumns, selectRangeColumns };

package/dist/engine/modules/editor/utils/selection.js

@@ -0,0 +1,16 @@
+import { SelectType } from "../state.js";
+//#region src/engine/modules/editor/utils/selection.ts
+function getSelectTypeIds(selectedMap) {
+	return Object.entries(selectedMap).reduce((acc, [id, type]) => {
+		if (type === SelectType.table) acc.tableIds.push(id);
+		else if (type === SelectType.memo) acc.memoIds.push(id);
+		else if (type === SelectType.tableGroup) acc.tableGroupIds.push(id);
+		return acc;
+	}, {
+		tableIds: [],
+		memoIds: [],
+		tableGroupIds: []
+	});
+}
+//#endregion
+export { getSelectTypeIds };

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

@@ -0,0 +1,134 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { zoomLevelInRange } from "../../../utils/validation.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { ActionType } from "./actions.js";
+import { CenterStep } from "./state.js";
+import { clearSortChannel } from "../../../utils/draw-relationship/index.js";
+import { createSceneView, getActiveView, isSameCenters, toSteppedCenters } from "./view.js";
+import { round } from "es-toolkit/compat";
+//#region src/engine/modules/editor/view.actions.ts
+function clearViewGeometry({ collections }, kind) {
+	clearSortChannel(query(collections).collection("relationshipEntities").selectAll(), kind);
+}
+var getAimedView = (state, kind) => kind ? state.editor.views[kind] : getActiveView(state);
+function clearViews(editor) {
+	editor.views.flow = null;
+}
+var viewOpenAction = createAction(ActionType.viewOpen);
+var viewOpen = (state, { payload: { kind, centerIds } }) => {
+	clearViewGeometry(state, kind);
+	state.editor.views[kind] = createSceneView(kind, centerIds);
+};
+var viewCloseAction = createAction(ActionType.viewClose);
+var viewClose = (state, { payload: { kind } }) => {
+	clearViewGeometry(state, kind);
+	state.editor.views[kind] = null;
+};
+var viewScrollToAction = createAction(ActionType.viewScrollTo);
+var viewScrollTo = (state, { payload: { originX, originY, kind } }) => {
+	const view = getAimedView(state, kind);
+	if (!view) return;
+	view.originX = round(originX, 4);
+	view.originY = round(originY, 4);
+};
+var viewStreamScrollToAction = createAction(ActionType.viewStreamScrollTo);
+var viewStreamScrollTo = (state, { payload: { movementX, movementY, kind } }) => {
+	const view = getAimedView(state, kind);
+	if (!view) return;
+	view.originX = round(view.originX + movementX, 4);
+	view.originY = round(view.originY + movementY, 4);
+};
+var viewChangeZoomLevelAction = createAction(ActionType.viewChangeZoomLevel);
+var viewChangeZoomLevel = (state, { payload: { value, kind } }) => {
+	const view = getAimedView(state, kind);
+	if (!view) return;
+	view.zoomLevel = zoomLevelInRange(value);
+};
+var viewStreamZoomLevelAction = createAction(ActionType.viewStreamZoomLevel);
+var viewStreamZoomLevel = (state, { payload: { value, kind } }) => {
+	const view = getAimedView(state, kind);
+	if (!view) return;
+	view.zoomLevel = zoomLevelInRange(view.zoomLevel + value);
+};
+var viewMoveTableAction = createAction(ActionType.viewMoveTable);
+var viewMoveTable = (state, { payload: { ids, movementX, movementY, kind } }) => {
+	const view = getAimedView(state, kind);
+	if (!view) return;
+	for (const id of ids) {
+		const point = view.positions[id];
+		if (!point) continue;
+		point.x = round(point.x + movementX, 4);
+		point.y = round(point.y + movementY, 4);
+	}
+};
+var viewSetLayoutAction = createAction(ActionType.viewSetLayout);
+var viewSetLayout = ({ editor }, { payload: { kind, positions } }) => {
+	const view = editor.views[kind];
+	if (!view) return;
+	view.positions = Object.fromEntries(Object.entries(positions).map(([id, { x, y }]) => [id, {
+		x,
+		y
+	}]));
+};
+var viewChangeShowModeAction = createAction(ActionType.viewChangeShowMode);
+var viewChangeShowMode = (state, { payload: { value, kind } }) => {
+	const view = getAimedView(state, kind);
+	if (!view) return;
+	view.showMode = value;
+};
+var viewSetCentersAction = createAction(ActionType.viewSetCenters);
+var viewSetCenters = (state, { payload: { tableIds, kind } }) => {
+	const view = getAimedView(state, kind);
+	if (!view || isSameCenters(view.centerIds, tableIds)) return;
+	view.previousCenterIds = [...view.previousCenterIds, view.centerIds].slice(-100).map((ids) => [...ids]);
+	view.nextCenterIds = [];
+	view.centerIds = [...tableIds];
+};
+var viewStepCentersAction = createAction(ActionType.viewStepCenters);
+var viewStepCenters = (state, { payload: { step, kind } }) => {
+	const view = getAimedView(state, kind);
+	if (!view) return;
+	const [from, to] = step === CenterStep.previous ? [view.previousCenterIds, view.nextCenterIds] : [view.nextCenterIds, view.previousCenterIds];
+	const tableIds = new Set(state.doc.tableIds);
+	for (let ids = from.pop(); ids; ids = from.pop()) {
+		const centerIds = toSteppedCenters(tableIds, view, ids);
+		if (!centerIds) continue;
+		to.push([...view.centerIds]);
+		view.centerIds = centerIds;
+		return;
+	}
+};
+var changeVisualizationModeAction = createAction(ActionType.changeVisualizationMode);
+var changeVisualizationMode = ({ editor }, { payload: { value } }) => {
+	editor.visualizationMode = value;
+};
+var viewReducers = {
+	[ActionType.viewOpen]: viewOpen,
+	[ActionType.viewClose]: viewClose,
+	[ActionType.viewScrollTo]: viewScrollTo,
+	[ActionType.viewStreamScrollTo]: viewStreamScrollTo,
+	[ActionType.viewChangeZoomLevel]: viewChangeZoomLevel,
+	[ActionType.viewStreamZoomLevel]: viewStreamZoomLevel,
+	[ActionType.viewMoveTable]: viewMoveTable,
+	[ActionType.viewSetLayout]: viewSetLayout,
+	[ActionType.viewChangeShowMode]: viewChangeShowMode,
+	[ActionType.viewSetCenters]: viewSetCenters,
+	[ActionType.viewStepCenters]: viewStepCenters,
+	[ActionType.changeVisualizationMode]: changeVisualizationMode
+};
+var viewActions = {
+	viewOpenAction,
+	viewCloseAction,
+	viewScrollToAction,
+	viewStreamScrollToAction,
+	viewChangeZoomLevelAction,
+	viewStreamZoomLevelAction,
+	viewMoveTableAction,
+	viewSetLayoutAction,
+	viewChangeShowModeAction,
+	viewSetCentersAction,
+	viewStepCentersAction,
+	changeVisualizationModeAction
+};
+//#endregion
+export { changeVisualizationModeAction, clearViews, viewActions, viewChangeShowModeAction, viewChangeZoomLevelAction, viewCloseAction, viewMoveTableAction, viewOpenAction, viewReducers, viewScrollToAction, viewSetCentersAction, viewSetLayoutAction, viewStepCentersAction, viewStreamScrollToAction, viewStreamZoomLevelAction };

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

@@ -0,0 +1,25 @@
+import { CanvasType } from "../../../constants/schema.js";
+import { SelectType, ViewKind, VisualizationMode } from "./state.js";
+import { changeVisualizationModeAction, viewOpenAction, viewSetCentersAction } from "./view.actions.js";
+import { changeCanvasTypeAction } from "../settings/atom.actions.js";
+//#region src/engine/modules/editor/view.generator.actions.ts
+var FLOW = ViewKind.flow;
+function focusCentersOf(selectedMap, tableId) {
+	if (tableId && selectedMap[tableId] !== SelectType.table) return [tableId];
+	return Object.entries(selectedMap).filter(([, selectType]) => selectType === SelectType.table).map(([id]) => id);
+}
+var focusFlowTableAction$ = (tableIds) => function* ({ editor, settings }) {
+	if (!tableIds.length) return;
+	if (settings.canvasType !== CanvasType.visualization) yield changeCanvasTypeAction({ value: CanvasType.visualization });
+	if (editor.visualizationMode !== VisualizationMode.flow) yield changeVisualizationModeAction({ value: VisualizationMode.flow });
+	yield editor.views.flow ? viewSetCentersAction({
+		tableIds,
+		kind: FLOW
+	}) : viewOpenAction({
+		kind: FLOW,
+		centerIds: tableIds
+	});
+};
+var viewActions$ = { focusFlowTableAction$ };
+//#endregion
+export { focusCentersOf, focusFlowTableAction$, viewActions$ };

package/dist/engine/modules/editor/view.js

@@ -0,0 +1,29 @@
+import { CanvasType } from "../../../constants/schema.js";
+import { ShowMode, VisualizationMode } from "./state.js";
+//#region src/engine/modules/editor/view.ts
+var showsFlowTab = (state) => state.settings.canvasType === CanvasType.visualization && state.editor.visualizationMode === VisualizationMode.flow;
+var getActiveView = (state) => showsFlowTab(state) ? state.editor.views.flow : null;
+var isViewShown = (state, kind) => state.editor.views[kind] !== null && showsFlowTab(state);
+var getSourceView = (state, source) => source === "document" ? null : state.editor.views[source];
+var isSameCenters = (a, b) => a.length === b.length && a.every((id, index) => id === b[index]);
+function toSteppedCenters(tableIds, view, centerIds) {
+	const live = centerIds.filter((id) => tableIds.has(id));
+	if (centerIds.length && !live.length) return null;
+	return isSameCenters(live, view.centerIds) ? null : live;
+}
+function createSceneView(kind, centerIds = []) {
+	const centers = [...centerIds];
+	return {
+		kind,
+		showMode: centers.length ? ShowMode.keysOnly : ShowMode.nameOnly,
+		positions: {},
+		originX: 0,
+		originY: 0,
+		zoomLevel: 1,
+		centerIds: centers,
+		previousCenterIds: [],
+		nextCenterIds: []
+	};
+}
+//#endregion
+export { createSceneView, getActiveView, getSourceView, isSameCenters, isViewShown, toSteppedCenters };

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

@@ -0,0 +1,9 @@
+//#region src/engine/modules/index/actions.ts
+var ActionType = {
+	addIndex: "index.add",
+	removeIndex: "index.remove",
+	changeIndexName: "index.changeName",
+	changeIndexUnique: "index.changeUnique"
+};
+//#endregion
+export { ActionType };