@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,584 @@
+import { parser } from "../../../erd-editor-schema/dist/v3/parser/index.js";
+import { parser as parser$1 } from "../../../erd-editor-schema/dist/parser.js";
+import { addOperator, removeOperator, replaceOperator } from "../../../erd-editor-schema/dist/query/lww.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { CanvasType, Show } from "../../../constants/schema.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { hasCanvasType } from "../../../utils/validation.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { ActionType } from "./actions.js";
+import { MoveKey, SelectType } from "./state.js";
+import { bHas } from "../../../utils/bit.js";
+import { getColumnFocusTypes, getTableFocusTypes, keepFocusShown, toShownFocusType } from "./utils/nameView.js";
+import { releaseHidden } from "./utils/releaseHidden.js";
+import { clearViews, viewActions, viewReducers } from "./view.actions.js";
+import { Tag } from "../../tag.js";
+import { toScenePoint } from "../../../konva/scene/viewport.js";
+import { endScreenBaseline } from "../settings/screenBaseline.js";
+import { getOpeningOrigin, hasViewport, landLoadedSettings, rememberCanvasType } from "../settings/atom.actions.js";
+import { settleDocument } from "../../settle.js";
+import { appendSelectColumns, appendSelectRangeColumns, selectRangeColumns } from "./utils/selectRangeColumn.js";
+import { arrowDown, arrowLeft, arrowRight, arrowUp } from "./utils/focus.js";
+import { isNil, isPlainObject, isString, noop } from "es-toolkit";
+import { isEmpty, round } from "es-toolkit/compat";
+//#region src/engine/modules/editor/atom.actions.ts
+var SHARED_MOUSE_TRACKER_TIMEOUT = 3e4;
+var SHARED_FOCUS_TRACKER_TIMEOUT = 9e4;
+var SHARED_DRAG_SELECT_TRACKER_TIMEOUT = 3e3;
+var changeHasHistoryAction = createAction(ActionType.changeHasHistory);
+var changeHasHistory = ({ editor }, { payload: { hasRedo, hasUndo, sheet } }) => {
+	if (sheet) {
+		editor.dictionaryHistory[sheet] = {
+			hasRedo,
+			hasUndo
+		};
+		return;
+	}
+	editor.hasRedo = hasRedo;
+	editor.hasUndo = hasUndo;
+};
+var selectAllAction = createAction(ActionType.selectAll);
+var selectAll = ({ editor, doc, settings }) => {
+	const tableSelectedMap = doc.tableIds.reduce((acc, id) => {
+		acc[id] = SelectType.table;
+		return acc;
+	}, {});
+	editor.selectedMap = {
+		...(bHas(settings.show, Show.hideMemo) ? [] : doc.memoIds).reduce((acc, id) => {
+			acc[id] = SelectType.memo;
+			return acc;
+		}, {}),
+		...tableSelectedMap
+	};
+};
+var unselectAllAction = createAction(ActionType.unselectAll);
+var unselectAll = ({ editor }) => {
+	Object.keys(editor.selectedMap).forEach((id) => {
+		Reflect.deleteProperty(editor.selectedMap, id);
+	});
+};
+var selectAction = createAction(ActionType.select);
+var SELECT_LISTS = {
+	[SelectType.table]: "tableIds",
+	[SelectType.memo]: "memoIds",
+	[SelectType.tableGroup]: "tableGroupIds"
+};
+var select = ({ doc, editor }, { payload }) => {
+	const listed = /* @__PURE__ */ new Map();
+	for (const [id, type] of Object.entries(payload)) {
+		let isListed = listed.get(type);
+		if (!isListed) {
+			isListed = arrayHas(doc[SELECT_LISTS[type]]);
+			listed.set(type, isListed);
+		}
+		if (isListed(id)) editor.selectedMap[id] = type;
+	}
+};
+var changeViewportAction = createAction(ActionType.changeViewport);
+var changeViewport = (state, { payload: { width, height } }) => {
+	state.editor.viewport.width = width;
+	state.editor.viewport.height = height;
+	if (state.editor.scrollPullPending) pullScrollIntoRange(state);
+};
+var clearAction = createAction(ActionType.clear);
+var keepsDictionaries = (payload) => isPlainObject(payload) && payload.keepDictionaries === true;
+function keepDictionaries(state, { doc, collections }) {
+	doc.wordIds = state.doc.wordIds;
+	doc.termIds = state.doc.termIds;
+	doc.domainIds = state.doc.domainIds;
+	collections.wordEntities = state.collections.wordEntities;
+	collections.termEntities = state.collections.termEntities;
+	collections.domainEntities = state.collections.domainEntities;
+}
+var clear = (state, { payload }) => {
+	const { doc, collections } = parser({});
+	if (keepsDictionaries(payload)) keepDictionaries(state, {
+		doc,
+		collections
+	});
+	state.doc = doc;
+	state.collections = collections;
+	state.editor.scrollPullPending = false;
+	clearViews(state.editor);
+};
+function pullScrollIntoRange(state) {
+	const { settings, editor } = state;
+	if (!hasViewport(editor.viewport)) {
+		editor.scrollPullPending = true;
+		return;
+	}
+	const origin = getOpeningOrigin(state);
+	settings.originX = round(origin.x, 4);
+	settings.originY = round(origin.y, 4);
+	editor.scrollPullPending = false;
+}
+var loadJsonAction = createAction(ActionType.loadJson);
+var loadJson = (state, { payload, version: actionVersion, tags }, ctx) => {
+	const { version, settings, doc, collections } = parser$1(payload.value);
+	if (!hasCanvasType(settings.canvasType)) settings.canvasType = CanvasType.ERD;
+	if (keepsDictionaries(payload)) keepDictionaries(state, {
+		doc,
+		collections
+	});
+	rememberCanvasType(state);
+	landLoadedSettings(state, settings, actionVersion ?? ctx.clock.getVersion(), tags);
+	state.version = version;
+	state.doc = doc;
+	state.collections = collections;
+	rememberCanvasType(state);
+	clearViews(state.editor);
+	releaseHidden(state);
+	keepFocusShown(state);
+	settleDocument(state, ctx);
+	pullScrollIntoRange(state);
+};
+var initialClearAction = createAction(ActionType.initialClear);
+var initialClear = (state) => {
+	const { doc, collections } = parser({});
+	state.doc = doc;
+	state.collections = collections;
+	state.editor.scrollPullPending = false;
+	clearViews(state.editor);
+};
+var initialLoadJsonAction = createAction(ActionType.initialLoadJson);
+var initialLoadJson = (state, { payload: { value } }, ctx) => {
+	const { version, settings, doc, collections } = parser$1(value);
+	if (!hasCanvasType(settings.canvasType)) settings.canvasType = CanvasType.ERD;
+	rememberCanvasType(state);
+	Object.assign(state.settings, settings);
+	state.version = version;
+	state.doc = doc;
+	state.collections = collections;
+	state.lww = {};
+	state.editor.screenBaseline = null;
+	rememberCanvasType(state);
+	clearViews(state.editor);
+	releaseHidden(state);
+	keepFocusShown(state);
+	settleDocument(state, ctx);
+	pullScrollIntoRange(state);
+};
+var focusTableAction = createAction(ActionType.focusTable);
+var toShownTableFocus = (settings, focusType) => toShownFocusType(settings, getTableFocusTypes(settings), focusType) ?? focusType;
+var focusTable = ({ editor, collections, settings }, { payload }) => {
+	const collection = query(collections).collection("tableEntities");
+	if (editor.focusTable?.tableId === payload.tableId && payload.focusType) {
+		editor.focusTable.focusType = toShownTableFocus(settings, payload.focusType);
+		editor.focusTable.columnId = null;
+		editor.focusTable.prevSelectColumnId = null;
+		editor.focusTable.selectColumnIds = [];
+	} else if (payload.focusType) {
+		const table = collection.selectById(payload.tableId);
+		if (!table) return;
+		editor.focusTable = {
+			tableId: table.id,
+			focusType: toShownTableFocus(settings, payload.focusType),
+			columnId: null,
+			prevSelectColumnId: null,
+			selectColumnIds: [],
+			edit: false
+		};
+	} else if (editor.focusTable?.tableId !== payload.tableId) {
+		const table = collection.selectById(payload.tableId);
+		if (!table) return;
+		editor.focusTable = {
+			tableId: table.id,
+			focusType: getTableFocusTypes(settings)[0],
+			columnId: null,
+			prevSelectColumnId: null,
+			selectColumnIds: [],
+			edit: false
+		};
+	}
+};
+var focusColumnAction = createAction(ActionType.focusColumn);
+var focusColumn = ({ editor, collections, settings }, { payload }) => {
+	const collection = query(collections).collection("tableEntities");
+	const focusType = toShownFocusType(settings, getColumnFocusTypes(settings), payload.focusType) ?? payload.focusType;
+	if (editor.focusTable?.tableId === payload.tableId) {
+		const table = collection.selectById(payload.tableId);
+		if (!table) return;
+		const focusTable = editor.focusTable;
+		focusTable.columnId = payload.columnId;
+		focusTable.focusType = focusType;
+		if (payload.$mod && payload.shiftKey) focusTable.selectColumnIds = appendSelectRangeColumns(table.columnIds, focusTable.selectColumnIds, focusTable.prevSelectColumnId, focusTable.columnId);
+		else if (payload.shiftKey) focusTable.selectColumnIds = selectRangeColumns(table.columnIds, focusTable.prevSelectColumnId, focusTable.columnId);
+		else if (payload.$mod) focusTable.selectColumnIds = appendSelectColumns(focusTable.selectColumnIds, payload.columnId);
+		else focusTable.selectColumnIds = [payload.columnId];
+		focusTable.prevSelectColumnId = payload.columnId;
+	} else {
+		const table = collection.selectById(payload.tableId);
+		if (!table) return;
+		editor.focusTable = {
+			tableId: table.id,
+			focusType,
+			columnId: payload.columnId,
+			prevSelectColumnId: payload.columnId,
+			selectColumnIds: [payload.columnId],
+			edit: false
+		};
+	}
+};
+var focusTableEndAction = createAction(ActionType.focusTableEnd);
+var focusTableEnd = ({ editor }) => {
+	editor.focusTable = null;
+};
+var focusMoveTableAction = createAction(ActionType.focusMoveTable);
+var focusMoveTable = (state, { payload }) => {
+	const { editor: { focusTable } } = state;
+	if (!focusTable) return;
+	focusTable.edit = false;
+	switch (payload.moveKey) {
+		case MoveKey.ArrowUp:
+			arrowUp(state, payload);
+			break;
+		case MoveKey.ArrowDown:
+			arrowDown(state, payload);
+			break;
+		case MoveKey.ArrowLeft:
+			arrowLeft(state, payload);
+			break;
+		case MoveKey.ArrowRight:
+			arrowRight(state, payload);
+			break;
+		case MoveKey.Tab: payload.shiftKey ? arrowLeft(state, payload) : arrowRight(state, payload);
+	}
+};
+var editTableAction = createAction(ActionType.editTable);
+var editTable = ({ editor: { focusTable } }) => {
+	if (!focusTable) return;
+	focusTable.edit = true;
+};
+var editTableEndAction = createAction(ActionType.editTableEnd);
+var editTableEnd = ({ editor: { focusTable } }) => {
+	if (!focusTable) return;
+	focusTable.edit = false;
+};
+var editMemoAction = createAction(ActionType.editMemo);
+var editMemo = ({ editor }, { payload: { id } }) => {
+	editor.editMemoId = id;
+};
+var editMemoEndAction = createAction(ActionType.editMemoEnd);
+var editMemoEnd = ({ editor }) => {
+	editor.editMemoId = null;
+};
+var editTableGroupAction = createAction(ActionType.editTableGroup);
+var editTableGroup = ({ editor }, { payload: { id } }) => {
+	editor.editTableGroupId = id;
+};
+var editTableGroupEndAction = createAction(ActionType.editTableGroupEnd);
+var editTableGroupEnd = ({ editor }) => {
+	editor.editTableGroupId = null;
+};
+var scrollMemoAction = createAction(ActionType.scrollMemo);
+var scrollMemo = ({ editor }, { payload: { id, scrollTop } }) => {
+	editor.memoScrollTopMap[id] = Number.isFinite(scrollTop) ? Math.max(0, scrollTop) : 0;
+};
+var selectAllColumnAction = createAction(ActionType.selectAllColumn);
+var selectAllColumn = ({ collections, editor: { focusTable } }) => {
+	if (!focusTable) return;
+	const table = query(collections).collection("tableEntities").selectById(focusTable.tableId);
+	if (!table) return;
+	focusTable.selectColumnIds = [...table.columnIds];
+};
+var drawStartRelationshipAction = createAction(ActionType.drawStartRelationship);
+var drawStartRelationship = ({ editor }, { payload: { relationshipType } }) => {
+	editor.drawRelationship = {
+		relationshipType,
+		start: null,
+		end: {
+			x: 0,
+			y: 0
+		}
+	};
+	editor.drawTableGroup = false;
+};
+var drawStartAddRelationshipAction = createAction(ActionType.drawStartAddRelationship);
+var drawStartAddRelationship = ({ editor: { drawRelationship }, collections }, { payload: { tableId } }) => {
+	if (!drawRelationship) return;
+	const table = query(collections).collection("tableEntities").selectById(tableId);
+	if (!table) return;
+	drawRelationship.start = {
+		tableId,
+		x: table.ui.x,
+		y: table.ui.y
+	};
+};
+var drawEndRelationshipAction = createAction(ActionType.drawEndRelationship);
+var drawEndRelationship = ({ editor }) => {
+	editor.drawRelationship = null;
+};
+var drawRelationshipAction = createAction(ActionType.drawRelationship);
+var drawRelationship = ({ editor: { drawRelationship }, settings }, { payload: { x, y } }) => {
+	if (!drawRelationship?.start) return;
+	const scenePoint = toScenePoint(settings, {
+		x,
+		y
+	});
+	drawRelationship.end.x = scenePoint.x;
+	drawRelationship.end.y = scenePoint.y;
+};
+var hoverColumnMapAction = createAction(ActionType.hoverColumnMap);
+var hoverColumnMap = ({ editor }, { payload: { columnIds } }) => {
+	Object.keys(editor.hoverColumnMap).forEach((id) => {
+		Reflect.deleteProperty(editor.hoverColumnMap, id);
+	});
+	for (const id of columnIds) editor.hoverColumnMap[id] = true;
+};
+var hoverRelationshipMapAction = createAction(ActionType.hoverRelationshipMap);
+var hoverRelationshipMap = ({ editor }, { payload: { relationshipIds } }) => {
+	Object.keys(editor.hoverRelationshipMap).forEach((id) => {
+		Reflect.deleteProperty(editor.hoverRelationshipMap, id);
+	});
+	for (const id of relationshipIds) editor.hoverRelationshipMap[id] = true;
+};
+var changeOpenMapAction = createAction(ActionType.changeOpenMap);
+var changeOpenMap = ({ editor }, { payload }) => {
+	Object.assign(editor.openMap, payload);
+};
+var changeHandToolAction = createAction(ActionType.changeHandTool);
+var changeHandTool = ({ editor }, { payload: { value } }) => {
+	editor.handTool = value;
+	if (value) {
+		editor.drawRelationship = null;
+		editor.drawTableGroup = false;
+	}
+};
+var changeDrawTableGroupAction = createAction(ActionType.changeDrawTableGroup);
+var changeDrawTableGroup = ({ editor }, { payload: { value } }) => {
+	editor.drawTableGroup = value;
+	if (value) {
+		editor.handTool = false;
+		editor.drawRelationship = null;
+	}
+};
+var changeZenModeAction = createAction(ActionType.changeZenMode);
+var changeZenMode = ({ editor }, { payload: { value } }) => {
+	editor.zenMode = value;
+};
+var dragstartColumnAction = createAction(ActionType.dragstartColumn);
+var dragstartColumn = ({ editor }, { payload }) => {
+	editor.draggableColumn = payload;
+	payload.columnIds.forEach((id) => {
+		editor.draggingColumnMap[id] = true;
+	});
+};
+var dragendColumnAction = createAction(ActionType.dragendColumn);
+var dragendColumn = ({ editor }) => {
+	editor.draggableColumn = null;
+	Object.keys(editor.draggingColumnMap).forEach((id) => {
+		Reflect.deleteProperty(editor.draggingColumnMap, id);
+	});
+};
+var sharedMouseTrackerAction = createAction(ActionType.sharedMouseTracker);
+var sharedMouseTracker = ({ editor }, { payload, tags, meta }) => {
+	if (isNil(tags) || !bHas(tags, Tag.shared) || !isString(meta?.editorId) || editor.id === meta.editorId) return;
+	const sharedMouseTracker = editor.sharedMouseTrackerMap[meta.editorId];
+	const nickname = !isString(meta.nickname) || isEmpty(meta.nickname.trim()) ? "user" : meta.nickname.trim();
+	if (sharedMouseTracker) {
+		sharedMouseTracker.x = payload.x;
+		sharedMouseTracker.y = payload.y;
+		sharedMouseTracker.nickname = nickname;
+		clearTimeout(sharedMouseTracker.timeoutId);
+		sharedMouseTracker.timeoutId = setTimeout(() => {
+			Reflect.deleteProperty(editor.sharedMouseTrackerMap, meta.editorId);
+		}, SHARED_MOUSE_TRACKER_TIMEOUT);
+	} else editor.sharedMouseTrackerMap[meta.editorId] = {
+		...payload,
+		id: meta.editorId,
+		nickname,
+		timeoutId: setTimeout(() => {
+			Reflect.deleteProperty(editor.sharedMouseTrackerMap, meta.editorId);
+		}, SHARED_MOUSE_TRACKER_TIMEOUT)
+	};
+};
+var sharedFocusTrackerAction = createAction(ActionType.sharedFocusTracker);
+var sharedFocusTracker = ({ editor }, { payload: { focus }, tags, meta }) => {
+	if (isNil(tags) || !bHas(tags, Tag.shared) || !isString(meta?.editorId) || editor.id === meta.editorId) return;
+	const sharedFocusTracker = editor.sharedFocusTrackerMap[meta.editorId];
+	if (!focus) {
+		if (sharedFocusTracker) {
+			clearTimeout(sharedFocusTracker.timeoutId);
+			Reflect.deleteProperty(editor.sharedFocusTrackerMap, meta.editorId);
+		}
+		return;
+	}
+	if (sharedFocusTracker) {
+		sharedFocusTracker.tableId = focus.tableId;
+		sharedFocusTracker.columnId = focus.columnId;
+		sharedFocusTracker.focusType = focus.focusType;
+		clearTimeout(sharedFocusTracker.timeoutId);
+		sharedFocusTracker.timeoutId = setTimeout(() => {
+			Reflect.deleteProperty(editor.sharedFocusTrackerMap, meta.editorId);
+		}, SHARED_FOCUS_TRACKER_TIMEOUT);
+	} else editor.sharedFocusTrackerMap[meta.editorId] = {
+		...focus,
+		id: meta.editorId,
+		timeoutId: setTimeout(() => {
+			Reflect.deleteProperty(editor.sharedFocusTrackerMap, meta.editorId);
+		}, SHARED_FOCUS_TRACKER_TIMEOUT)
+	};
+};
+var sharedSelectionTrackerAction = createAction(ActionType.sharedSelectionTracker);
+var sharedSelectionTracker = ({ editor }, { payload: { selectedIds }, tags, meta }) => {
+	if (isNil(tags) || !bHas(tags, Tag.shared) || !isString(meta?.editorId) || editor.id === meta.editorId) return;
+	const sharedSelectionTracker = editor.sharedSelectionTrackerMap[meta.editorId];
+	if (!selectedIds.length) {
+		if (sharedSelectionTracker) {
+			clearTimeout(sharedSelectionTracker.timeoutId);
+			Reflect.deleteProperty(editor.sharedSelectionTrackerMap, meta.editorId);
+		}
+		return;
+	}
+	if (sharedSelectionTracker) {
+		sharedSelectionTracker.selectedIds = selectedIds;
+		clearTimeout(sharedSelectionTracker.timeoutId);
+		sharedSelectionTracker.timeoutId = setTimeout(() => {
+			Reflect.deleteProperty(editor.sharedSelectionTrackerMap, meta.editorId);
+		}, SHARED_FOCUS_TRACKER_TIMEOUT);
+	} else editor.sharedSelectionTrackerMap[meta.editorId] = {
+		id: meta.editorId,
+		selectedIds,
+		timeoutId: setTimeout(() => {
+			Reflect.deleteProperty(editor.sharedSelectionTrackerMap, meta.editorId);
+		}, SHARED_FOCUS_TRACKER_TIMEOUT)
+	};
+};
+var sharedDragSelectTrackerAction = createAction(ActionType.sharedDragSelectTracker);
+var sharedDragSelectTracker = ({ editor }, { payload: { rect }, tags, meta }) => {
+	if (isNil(tags) || !bHas(tags, Tag.shared) || !isString(meta?.editorId) || editor.id === meta.editorId) return;
+	const sharedDragSelectTracker = editor.sharedDragSelectTrackerMap[meta.editorId];
+	if (!rect) {
+		if (sharedDragSelectTracker) {
+			clearTimeout(sharedDragSelectTracker.timeoutId);
+			Reflect.deleteProperty(editor.sharedDragSelectTrackerMap, meta.editorId);
+		}
+		return;
+	}
+	if (sharedDragSelectTracker) {
+		sharedDragSelectTracker.x = rect.x;
+		sharedDragSelectTracker.y = rect.y;
+		sharedDragSelectTracker.w = rect.w;
+		sharedDragSelectTracker.h = rect.h;
+		clearTimeout(sharedDragSelectTracker.timeoutId);
+		sharedDragSelectTracker.timeoutId = setTimeout(() => {
+			Reflect.deleteProperty(editor.sharedDragSelectTrackerMap, meta.editorId);
+		}, SHARED_DRAG_SELECT_TRACKER_TIMEOUT);
+	} else editor.sharedDragSelectTrackerMap[meta.editorId] = {
+		...rect,
+		id: meta.editorId,
+		timeoutId: setTimeout(() => {
+			Reflect.deleteProperty(editor.sharedDragSelectTrackerMap, meta.editorId);
+		}, SHARED_DRAG_SELECT_TRACKER_TIMEOUT)
+	};
+};
+var dragSelectRectAction = createAction(ActionType.dragSelectRect);
+var dragSelectRect = ({ editor }, { payload: { rect } }) => {
+	editor.dragSelect = rect;
+};
+var getLWWAction = createAction(ActionType.getLWW);
+var getLWW = noop;
+var mergeLWWAction = createAction(ActionType.mergeLWW);
+var mergeLWW = ({ lww }, { payload: { lww: remoteLWW } }) => {
+	Object.entries(remoteLWW).forEach(([id, [tag, addVersion, removeVersion, replaceRecord]]) => {
+		addOperator(lww, addVersion, id, tag, noop);
+		removeOperator(lww, removeVersion, id, tag, noop);
+		Object.entries(replaceRecord).forEach(([path, replaceVersion]) => {
+			replaceOperator(lww, replaceVersion, id, tag, path, noop);
+		});
+	});
+};
+var endScreenSettingsAction = createAction(ActionType.endScreenSettings);
+var endScreenSettings = ({ editor }, { payload: { units } }) => {
+	endScreenBaseline(editor, ...units);
+};
+var editorReducers = {
+	[ActionType.changeHasHistory]: changeHasHistory,
+	[ActionType.selectAll]: selectAll,
+	[ActionType.unselectAll]: unselectAll,
+	[ActionType.select]: select,
+	[ActionType.changeViewport]: changeViewport,
+	[ActionType.clear]: clear,
+	[ActionType.loadJson]: loadJson,
+	[ActionType.initialClear]: initialClear,
+	[ActionType.initialLoadJson]: initialLoadJson,
+	[ActionType.focusTable]: focusTable,
+	[ActionType.focusColumn]: focusColumn,
+	[ActionType.focusTableEnd]: focusTableEnd,
+	[ActionType.focusMoveTable]: focusMoveTable,
+	[ActionType.editTable]: editTable,
+	[ActionType.editTableEnd]: editTableEnd,
+	[ActionType.editMemo]: editMemo,
+	[ActionType.editMemoEnd]: editMemoEnd,
+	[ActionType.editTableGroup]: editTableGroup,
+	[ActionType.editTableGroupEnd]: editTableGroupEnd,
+	[ActionType.scrollMemo]: scrollMemo,
+	[ActionType.selectAllColumn]: selectAllColumn,
+	[ActionType.drawStartRelationship]: drawStartRelationship,
+	[ActionType.drawStartAddRelationship]: drawStartAddRelationship,
+	[ActionType.drawEndRelationship]: drawEndRelationship,
+	[ActionType.drawRelationship]: drawRelationship,
+	[ActionType.hoverColumnMap]: hoverColumnMap,
+	[ActionType.hoverRelationshipMap]: hoverRelationshipMap,
+	[ActionType.changeOpenMap]: changeOpenMap,
+	[ActionType.changeHandTool]: changeHandTool,
+	[ActionType.changeDrawTableGroup]: changeDrawTableGroup,
+	[ActionType.changeZenMode]: changeZenMode,
+	[ActionType.dragstartColumn]: dragstartColumn,
+	[ActionType.dragendColumn]: dragendColumn,
+	[ActionType.sharedMouseTracker]: sharedMouseTracker,
+	[ActionType.sharedFocusTracker]: sharedFocusTracker,
+	[ActionType.sharedSelectionTracker]: sharedSelectionTracker,
+	[ActionType.sharedDragSelectTracker]: sharedDragSelectTracker,
+	[ActionType.dragSelectRect]: dragSelectRect,
+	[ActionType.getLWW]: getLWW,
+	[ActionType.mergeLWW]: mergeLWW,
+	[ActionType.endScreenSettings]: endScreenSettings,
+	...viewReducers
+};
+var actions = {
+	changeHasHistoryAction,
+	selectAllAction,
+	unselectAllAction,
+	selectAction,
+	changeViewportAction,
+	clearAction,
+	loadJsonAction,
+	initialClearAction,
+	initialLoadJsonAction,
+	focusTableAction,
+	focusColumnAction,
+	focusTableEndAction,
+	focusMoveTableAction,
+	editTableAction,
+	editTableEndAction,
+	editMemoAction,
+	editMemoEndAction,
+	editTableGroupAction,
+	editTableGroupEndAction,
+	scrollMemoAction,
+	selectAllColumnAction,
+	drawStartRelationshipAction,
+	drawStartAddRelationshipAction,
+	drawEndRelationshipAction,
+	drawRelationshipAction,
+	hoverColumnMapAction,
+	hoverRelationshipMapAction,
+	changeOpenMapAction,
+	changeHandToolAction,
+	changeDrawTableGroupAction,
+	changeZenModeAction,
+	dragstartColumnAction,
+	dragendColumnAction,
+	sharedMouseTrackerAction,
+	sharedFocusTrackerAction,
+	sharedSelectionTrackerAction,
+	sharedDragSelectTrackerAction,
+	dragSelectRectAction,
+	getLWWAction,
+	mergeLWWAction,
+	endScreenSettingsAction,
+	...viewActions
+};
+//#endregion
+export { SHARED_DRAG_SELECT_TRACKER_TIMEOUT, SHARED_FOCUS_TRACKER_TIMEOUT, actions, changeDrawTableGroupAction, changeHandToolAction, changeHasHistoryAction, changeOpenMapAction, changeViewportAction, changeZenModeAction, clearAction, dragSelectRectAction, dragendColumnAction, dragstartColumnAction, drawEndRelationshipAction, drawRelationshipAction, drawStartAddRelationshipAction, drawStartRelationshipAction, editMemoAction, editMemoEndAction, editTableAction, editTableEndAction, editTableGroupAction, editTableGroupEndAction, editorReducers, endScreenSettingsAction, focusColumnAction, focusMoveTableAction, focusTableAction, focusTableEndAction, getLWWAction, hoverColumnMapAction, hoverRelationshipMapAction, initialClearAction, initialLoadJsonAction, keepsDictionaries, loadJsonAction, mergeLWWAction, scrollMemoAction, selectAction, selectAllAction, selectAllColumnAction, sharedDragSelectTrackerAction, sharedFocusTrackerAction, sharedMouseTrackerAction, sharedSelectionTrackerAction, unselectAllAction };