@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,37 @@
+import { toJson } from "../../../erd-editor-schema/dist/parser.js";
+import { ActionType } from "./actions.js";
+import { clearAction, keepsDictionaries, loadJsonAction } from "./atom.actions.js";
+//#region src/engine/modules/editor/history.ts
+function toUndoLoad(state, keep) {
+	if (!keep) return loadJsonAction({ value: toJson(state) });
+	const value = toJson({
+		...state,
+		doc: {
+			...state.doc,
+			wordIds: [],
+			termIds: []
+		},
+		collections: {
+			...state.collections,
+			wordEntities: {},
+			termEntities: {}
+		}
+	});
+	return loadJsonAction({
+		value,
+		keepDictionaries: true
+	});
+}
+var loadJson = (undoActions, { payload }, state) => {
+	const keep = keepsDictionaries(payload);
+	undoActions.push(clearAction(keep ? { keepDictionaries: true } : void 0), toUndoLoad(state, keep));
+};
+var clear = (undoActions, { payload }, state) => {
+	undoActions.push(toUndoLoad(state, keepsDictionaries(payload)));
+};
+var editorPushUndoHistoryMap = {
+	[ActionType.loadJson]: loadJson,
+	[ActionType.clear]: clear
+};
+//#endregion
+export { editorPushUndoHistoryMap };

package/dist/engine/modules/editor/state.d.ts

@@ -1,3 +1,4 @@
+import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
 import { DictionaryKind } from '../dictionary/actions';
 import { Point, ValuesType } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
@@ -67,7 +68,26 @@ export type Editor = {
      * one a canvas type lock taken on the Settings tab holds.
      */
     lastCanvasType: string;
+    /**
+     * The document's own value of each setting a readonly reader turned on its
+     * screen, null while none is held. Local to this client, never the file, the
+     * history or a peer.
+     */
+    screenBaseline: ScreenBaseline | null;
+};
+type Settings = ERDEditorSchemaV3['settings'];
+/** The placement fields a screen turns as one, since one saved alone opens elsewhere. */
+export type ScreenViewport = Pick<Settings, 'originX' | 'originY' | 'zoomLevel'>;
+/**
+ * Each setting the document holds under a reader's screen, by unit, recorded
+ * by the first screen turn of that unit and dropped once the document's value
+ * may show again.
+ */
+export type ScreenBaseline = Partial<Pick<Settings, 'canvasType' | 'nameViewMode' | 'show' | 'database' | 'language' | 'tableNameCase' | 'columnNameCase' | 'bracketType'>> & {
+    viewport?: ScreenViewport;
 };
+/** A unit of the baseline: the viewport, or one setting of its own. */
+export type ScreenUnit = keyof ScreenBaseline;
 export type Viewport = {
     width: number;
     height: number;
@@ -202,4 +222,5 @@ export declare const isEditingMemo: ({ editMemoId }: Editor) => boolean;
  */
 export declare const isEditingText: (editor: Editor) => boolean;
 export declare const createEditor: () => Editor;
+export {};
 //# sourceMappingURL=state.d.ts.map

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

@@ -0,0 +1,97 @@
+import { DEFAULT_WIDTH } from "../../../constants/layout.js";
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { CanvasType } from "../../../constants/schema.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+//#region src/engine/modules/editor/state.ts
+var SelectType = {
+	table: "table",
+	memo: "memo",
+	tableGroup: "tableGroup"
+};
+var ShowMode = {
+	nameOnly: "nameOnly",
+	keysOnly: "keysOnly",
+	allFields: "allFields"
+};
+var ViewKind = { flow: "flow" };
+var VisualizationMode = {
+	graph: "graph",
+	flow: "flow"
+};
+var CenterStep = {
+	previous: "previous",
+	next: "next"
+};
+var FocusType = {
+	tableName: "tableName",
+	tableComment: "tableComment",
+	columnName: "columnName",
+	columnDataType: "columnDataType",
+	columnNotNull: "columnNotNull",
+	columnUnique: "columnUnique",
+	columnAutoIncrement: "columnAutoIncrement",
+	columnDefault: "columnDefault",
+	columnComment: "columnComment",
+	tableLogicalName: "tableLogicalName",
+	columnLogicalName: "columnLogicalName",
+	columnDomain: "columnDomain"
+};
+var MoveKey = {
+	ArrowUp: "ArrowUp",
+	ArrowRight: "ArrowRight",
+	ArrowDown: "ArrowDown",
+	ArrowLeft: "ArrowLeft",
+	Tab: "Tab"
+};
+var hasMoveKeys = arrayHas(Object.values(MoveKey));
+var isEditingMemo = ({ editMemoId }) => Boolean(editMemoId);
+var isEditingText = (editor) => isEditingMemo(editor) || Boolean(editor.focusTable?.edit) || Boolean(editor.editTableGroupId);
+var createEditor = () => ({
+	id: uuid25(),
+	selectedMap: {},
+	hasUndo: false,
+	hasRedo: false,
+	dictionaryHistory: {
+		word: {
+			hasUndo: false,
+			hasRedo: false
+		},
+		term: {
+			hasUndo: false,
+			hasRedo: false
+		},
+		domain: {
+			hasUndo: false,
+			hasRedo: false
+		}
+	},
+	viewport: {
+		width: DEFAULT_WIDTH,
+		height: 675
+	},
+	scrollPullPending: false,
+	focusTable: null,
+	editMemoId: null,
+	editTableGroupId: null,
+	memoScrollTopMap: {},
+	drawRelationship: null,
+	hoverColumnMap: {},
+	hoverRelationshipMap: {},
+	openMap: {},
+	handTool: false,
+	drawTableGroup: false,
+	zenMode: false,
+	draggableColumn: null,
+	draggingColumnMap: {},
+	sharedMouseTrackerMap: {},
+	sharedFocusTrackerMap: {},
+	sharedSelectionTrackerMap: {},
+	sharedDragSelectTrackerMap: {},
+	dragSelect: null,
+	views: { flow: null },
+	visualizationMode: VisualizationMode.graph,
+	lastCanvasType: CanvasType.ERD,
+	screenBaseline: null
+});
+//#endregion
+export { CenterStep, FocusType, MoveKey, SelectType, ShowMode, ViewKind, VisualizationMode, createEditor, hasMoveKeys, isEditingMemo, isEditingText };

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

@@ -0,0 +1,37 @@
+import { query } from "../../../../erd-editor-schema/dist/query/index.js";
+import { toOpaqueHex } from "../../../../utils/tableColor.js";
+import { getSelectTypeIds } from "./selection.js";
+//#region src/engine/modules/editor/utils/color.ts
+function getColorTargets({ editor: { selectedMap }, collections }) {
+	const { tableIds, memoIds, tableGroupIds } = getSelectTypeIds(selectedMap);
+	return {
+		tables: query(collections).collection("tableEntities").selectByIds(tableIds),
+		memos: query(collections).collection("memoEntities").selectByIds(memoIds),
+		tableGroups: query(collections).collection("tableGroupEntities").selectByIds(tableGroupIds)
+	};
+}
+function getColoredSelection(state) {
+	const { tables, memos, tableGroups } = getColorTargets(state);
+	return {
+		tables: tables.filter((table) => table.ui.color !== ""),
+		memos: memos.filter((memo) => memo.ui.color !== ""),
+		tableGroups: tableGroups.filter((group) => group.color !== "")
+	};
+}
+function hasColoredSelection(state) {
+	const { tables, memos, tableGroups } = getColoredSelection(state);
+	return tables.length !== 0 || memos.length !== 0 || tableGroups.length !== 0;
+}
+function getDocumentColors({ doc, collections }) {
+	const tables = query(collections).collection("tableEntities").selectByIds(doc.tableIds);
+	const memos = query(collections).collection("memoEntities").selectByIds(doc.memoIds);
+	const groups = query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds);
+	const counts = /* @__PURE__ */ new Map();
+	for (const value of [...[...tables, ...memos].map(({ ui }) => ui.color), ...groups.map(({ color }) => color)]) {
+		const color = toOpaqueHex(value);
+		if (color) counts.set(color, (counts.get(color) ?? 0) + 1);
+	}
+	return [...counts].sort(([, a], [, b]) => b - a).map(([color]) => color);
+}
+//#endregion
+export { getColorTargets, getColoredSelection, getDocumentColors, hasColoredSelection };

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

@@ -0,0 +1,234 @@
+import { uuid25 } from "../../../../uuid/dist/uuid25.js";
+import { ColumnOption, OrderType } from "../../../../constants/schema.js";
+import { addColumnAction, changeColumnAutoIncrementAction, changeColumnCommentAction, changeColumnDataTypeAction, changeColumnDefaultAction, changeColumnDomainAction, changeColumnLogicalNameAction, changeColumnNameAction, changeColumnNameDerivedAction, changeColumnNotNullAction, changeColumnPrimaryKeyAction, changeColumnUniqueAction } from "../../table-column/atom.actions.js";
+import { bHas } from "../../../../utils/bit.js";
+import { addIndexAction, changeIndexNameAction, changeIndexUniqueAction } from "../../index/atom.actions.js";
+import { addIndexColumnAction, changeIndexColumnOrderTypeAction } from "../../index-column/atom.actions.js";
+import { addMemoAction, changeMemoValueAction } from "../../memo/atom.actions.js";
+import { addRelationshipAction } from "../../relationship/atom.actions.js";
+import { addTableAction, changeTableCommentAction, changeTableGroupAction, changeTableLogicalNameAction, changeTableNameAction, changeTableNameDerivedAction } from "../../table/atom.actions.js";
+import { addTableGroupAction, changeTableGroupNameAction } from "../../table-group/atom.actions.js";
+//#region src/engine/modules/editor/utils/duplicate.ts
+function toCreateEntityActions({ tables, columns, memos, relationships, indexes, tableGroups = [] }, placement, { valuesOnly = false } = {}) {
+	const actions = [];
+	const set = (holds, action) => {
+		(holds || !valuesOnly) && actions.push(action);
+	};
+	const carry = (holds, action) => {
+		holds && actions.push(action);
+	};
+	const tableIds = [];
+	const memoIds = [];
+	const tableGroupIds = [];
+	const columnBySourceId = new Map(columns.map((column) => [column.sourceId, column]));
+	const tableIdBySourceId = /* @__PURE__ */ new Map();
+	const columnIdBySourceId = /* @__PURE__ */ new Map();
+	for (const table of tables) {
+		const point = placement.get(table.sourceId);
+		if (!point) continue;
+		const tableId = uuid25();
+		tableIds.push(tableId);
+		tableIdBySourceId.set(table.sourceId, tableId);
+		actions.push(addTableAction({
+			id: tableId,
+			ui: {
+				x: point.x,
+				y: point.y,
+				zIndex: point.zIndex,
+				color: table.ui.color
+			}
+		}));
+		set(!!table.name, changeTableNameAction({
+			id: tableId,
+			value: table.name
+		}));
+		carry(!!table.logicalName, changeTableLogicalNameAction({
+			id: tableId,
+			value: table.logicalName ?? ""
+		}));
+		set(!!table.comment, changeTableCommentAction({
+			id: tableId,
+			value: table.comment
+		}));
+		carry(table.nameDerived === true, changeTableNameDerivedAction({
+			id: tableId,
+			value: true
+		}));
+		for (const sourceColumnId of table.columnIds) {
+			const column = columnBySourceId.get(sourceColumnId);
+			if (!column) continue;
+			const payload = {
+				id: uuid25(),
+				tableId
+			};
+			columnIdBySourceId.set(sourceColumnId, payload.id);
+			const primaryKey = bHas(column.options, ColumnOption.primaryKey);
+			const notNull = bHas(column.options, ColumnOption.notNull);
+			const unique = bHas(column.options, ColumnOption.unique);
+			const autoIncrement = bHas(column.options, ColumnOption.autoIncrement);
+			actions.push(addColumnAction(payload));
+			set(!!column.name, changeColumnNameAction({
+				...payload,
+				value: column.name
+			}));
+			carry(!!column.logicalName, changeColumnLogicalNameAction({
+				...payload,
+				value: column.logicalName ?? ""
+			}));
+			set(!!column.dataType, changeColumnDataTypeAction({
+				...payload,
+				value: column.dataType
+			}));
+			carry(!!column.domainId, changeColumnDomainAction({
+				...payload,
+				value: column.domainId ?? ""
+			}));
+			set(!!column.default, changeColumnDefaultAction({
+				...payload,
+				value: column.default
+			}));
+			set(!!column.comment, changeColumnCommentAction({
+				...payload,
+				value: column.comment
+			}));
+			set(primaryKey, changeColumnPrimaryKeyAction({
+				...payload,
+				value: primaryKey
+			}));
+			set(notNull, changeColumnNotNullAction({
+				...payload,
+				value: notNull
+			}));
+			set(unique, changeColumnUniqueAction({
+				...payload,
+				value: unique
+			}));
+			set(autoIncrement, changeColumnAutoIncrementAction({
+				...payload,
+				value: autoIncrement
+			}));
+			carry(bHas(column.options, ColumnOption.nameDerived), changeColumnNameDerivedAction({
+				...payload,
+				value: true
+			}));
+		}
+	}
+	for (const relationship of relationships) {
+		const startTableId = tableIdBySourceId.get(relationship.start.tableId);
+		const endTableId = tableIdBySourceId.get(relationship.end.tableId);
+		if (!startTableId || !endTableId) continue;
+		const startColumnIds = toNewColumnIds(relationship.start.columnIds, columnIdBySourceId);
+		const endColumnIds = toNewColumnIds(relationship.end.columnIds, columnIdBySourceId);
+		if (!startColumnIds || !endColumnIds) continue;
+		actions.push(addRelationshipAction({
+			id: uuid25(),
+			relationshipType: relationship.relationshipType,
+			onDelete: relationship.onDelete,
+			onUpdate: relationship.onUpdate,
+			start: {
+				tableId: startTableId,
+				columnIds: startColumnIds
+			},
+			end: {
+				tableId: endTableId,
+				columnIds: endColumnIds
+			}
+		}));
+	}
+	for (const index of indexes) {
+		const tableId = tableIdBySourceId.get(index.tableId);
+		if (!tableId) continue;
+		const columnIds = toNewColumnIds(index.indexColumns.map(({ columnId }) => columnId), columnIdBySourceId);
+		if (!columnIds) continue;
+		const indexId = uuid25();
+		actions.push(addIndexAction({
+			id: indexId,
+			tableId
+		}));
+		set(!!index.name, changeIndexNameAction({
+			id: indexId,
+			tableId,
+			value: index.name
+		}));
+		set(index.unique, changeIndexUniqueAction({
+			id: indexId,
+			tableId,
+			value: index.unique
+		}));
+		index.indexColumns.forEach(({ orderType }, i) => {
+			const id = uuid25();
+			const columnId = columnIds[i];
+			actions.push(addIndexColumnAction({
+				id,
+				indexId,
+				tableId,
+				columnId
+			}));
+			set(orderType !== OrderType.ASC, changeIndexColumnOrderTypeAction({
+				id,
+				indexId,
+				columnId,
+				value: orderType
+			}));
+		});
+	}
+	for (const memo of memos) {
+		const point = placement.get(memo.sourceId);
+		if (!point) continue;
+		const memoId = uuid25();
+		memoIds.push(memoId);
+		actions.push(addMemoAction({
+			id: memoId,
+			ui: {
+				x: point.x,
+				y: point.y,
+				zIndex: point.zIndex,
+				color: memo.ui.color,
+				width: memo.ui.width,
+				height: memo.ui.height
+			}
+		}));
+		set(!!memo.value, changeMemoValueAction({
+			id: memoId,
+			value: memo.value
+		}));
+	}
+	for (const group of tableGroups) {
+		const tableGroupId = uuid25();
+		tableGroupIds.push(tableGroupId);
+		actions.push(addTableGroupAction({
+			id: tableGroupId,
+			color: group.color,
+			ui: { ...group.ui }
+		}));
+		set(!!group.name, changeTableGroupNameAction({
+			id: tableGroupId,
+			value: group.name
+		}));
+		for (const sourceTableId of group.tableIds) {
+			const tableId = tableIdBySourceId.get(sourceTableId);
+			if (!tableId) continue;
+			actions.push(changeTableGroupAction({
+				id: tableId,
+				value: tableGroupId
+			}));
+		}
+	}
+	return {
+		actions,
+		tableIds,
+		memoIds,
+		tableGroupIds
+	};
+}
+function toNewColumnIds(sourceColumnIds, columnIdBySourceId) {
+	const columnIds = [];
+	for (const sourceColumnId of sourceColumnIds) {
+		const columnId = columnIdBySourceId.get(sourceColumnId);
+		if (!columnId) return null;
+		columnIds.push(columnId);
+	}
+	return columnIds;
+}
+//#endregion
+export { toCreateEntityActions };

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

@@ -0,0 +1,34 @@
+import { query } from "../../../../erd-editor-schema/dist/query/index.js";
+//#region src/engine/modules/editor/utils/findRelationshipColumn.ts
+function findRelationshipColumn(stack, state, result = []) {
+	const { doc: { relationshipIds }, collections } = state;
+	const target = stack.pop();
+	if (target) {
+		if (!result.some(({ columnId }) => columnId === target.columnId)) {
+			result.push(target);
+			query(collections).collection("relationshipEntities").selectByIds(relationshipIds).forEach(({ id: relationshipId, start, end }) => {
+				const index = start.columnIds.indexOf(target.columnId);
+				if (index !== -1) {
+					const columnId = end.columnIds[index];
+					stack.push({
+						columnId,
+						relationshipIds: [relationshipId]
+					});
+				} else {
+					const index = end.columnIds.indexOf(target.columnId);
+					if (index !== -1) {
+						const columnId = start.columnIds[index];
+						stack.push({
+							columnId,
+							relationshipIds: [relationshipId]
+						});
+					}
+				}
+			});
+		}
+		findRelationshipColumn(stack, state, result);
+	}
+	return result;
+}
+//#endregion
+export { findRelationshipColumn };

package/dist/engine/modules/editor/utils/focus.d.ts

@@ -5,6 +5,11 @@ type Payload = ActionMap[typeof ActionType.focusMoveTable];
 export declare function isColumns({ collections, editor: { focusTable } }: RootState): boolean;
 export declare function isLastColumn(state: RootState): boolean;
 export declare function isLastRowColumn({ collections, editor: { focusTable }, }: RootState): boolean;
+/**
+ * The cell a row's focus starts on, the first the view lays out: the one a
+ * new column takes, the logical name in the view of both under the default order.
+ */
+export declare function getFirstColumnType(state: RootState): FocusType;
 export declare function getRemoveFirstColumnId(state: RootState, columnIds: string[]): string | null;
 /**
  * The columns a command on the focused column reaches: the selection still in