@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,103 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ReferentialAction } from "../../../constants/schema.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { ActionType } from "./actions.js";
+import { createRelationship } from "../../../utils/collection/relationship.entity.js";
+//#region src/engine/modules/relationship/atom.actions.ts
+var addRelationshipAction = createAction(ActionType.addRelationship);
+var addRelationship = ({ doc, collections, lww }, { payload: { id, relationshipType, onDelete, onUpdate, start, end }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("relationshipEntities").addOne(createRelationship({
+		id,
+		relationshipType,
+		onDelete: onDelete ?? ReferentialAction.none,
+		onUpdate: onUpdate ?? ReferentialAction.none,
+		start: {
+			tableId: start.tableId,
+			columnIds: start.columnIds
+		},
+		end: {
+			tableId: end.tableId,
+			columnIds: end.columnIds
+		}
+	})).addOperator(lww, safeVersion, id, () => {
+		if (!arrayHas(doc.relationshipIds)(id)) doc.relationshipIds.push(id);
+	});
+};
+var removeRelationshipAction = createAction(ActionType.removeRelationship);
+var removeRelationship = ({ doc, collections, lww }, { payload: { id }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	query(collections).collection("relationshipEntities").removeOperator(lww, safeVersion, id, () => {
+		const index = doc.relationshipIds.indexOf(id);
+		if (index !== -1) doc.relationshipIds.splice(index, 1);
+	});
+};
+var changeRelationshipTypeAction = createAction(ActionType.changeRelationshipType);
+var changeRelationshipType = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("relationshipEntities");
+	collection.replaceOperator(lww, safeVersion, id, "relationshipType", () => {
+		collection.updateOne(id, (relationship) => {
+			relationship.relationshipType = value;
+		});
+	});
+};
+var changeRelationshipOnDeleteAction = createAction(ActionType.changeRelationshipOnDelete);
+var changeRelationshipOnDelete = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("relationshipEntities");
+	collection.replaceOperator(lww, safeVersion, id, "onDelete", () => {
+		collection.updateOne(id, (relationship) => {
+			relationship.onDelete = value;
+		});
+	});
+};
+var changeRelationshipOnUpdateAction = createAction(ActionType.changeRelationshipOnUpdate);
+var changeRelationshipOnUpdate = ({ collections, lww }, { payload: { id, value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("relationshipEntities");
+	collection.replaceOperator(lww, safeVersion, id, "onUpdate", () => {
+		collection.updateOne(id, (relationship) => {
+			relationship.onUpdate = value;
+		});
+	});
+};
+var changeRelationshipColumnsAction = createAction(ActionType.changeRelationshipColumns);
+var COLUMNS = "columns";
+var toColumnsKey = (startColumnIds, endColumnIds) => JSON.stringify([startColumnIds, endColumnIds]);
+var namesOtherTables = (relationship, { start, end }) => relationship.start.tableId !== start.tableId || relationship.end.tableId !== end.tableId;
+var changeRelationshipColumns = ({ collections, lww }, { payload: { id, start, end }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	const collection = query(collections).collection("relationshipEntities");
+	const relationship = collection.selectById(id);
+	if (relationship && namesOtherTables(relationship, {
+		start,
+		end
+	})) return;
+	if (relationship && (lww[id]?.[3][COLUMNS] ?? -1) === safeVersion && toColumnsKey(start.columnIds, end.columnIds) <= toColumnsKey(relationship.start.columnIds, relationship.end.columnIds)) return;
+	collection.replaceOperator(lww, safeVersion, id, COLUMNS, () => {
+		collection.updateOne(id, (value) => {
+			value.start.columnIds = [...start.columnIds];
+			value.end.columnIds = [...end.columnIds];
+		});
+	});
+};
+var relationshipReducers = {
+	[ActionType.addRelationship]: addRelationship,
+	[ActionType.removeRelationship]: removeRelationship,
+	[ActionType.changeRelationshipType]: changeRelationshipType,
+	[ActionType.changeRelationshipOnDelete]: changeRelationshipOnDelete,
+	[ActionType.changeRelationshipOnUpdate]: changeRelationshipOnUpdate,
+	[ActionType.changeRelationshipColumns]: changeRelationshipColumns
+};
+var actions = {
+	addRelationshipAction,
+	removeRelationshipAction,
+	changeRelationshipTypeAction,
+	changeRelationshipOnDeleteAction,
+	changeRelationshipOnUpdateAction,
+	changeRelationshipColumnsAction
+};
+//#endregion
+export { actions, addRelationshipAction, changeRelationshipColumnsAction, changeRelationshipOnDeleteAction, changeRelationshipOnUpdateAction, changeRelationshipTypeAction, namesOtherTables, relationshipReducers, removeRelationshipAction };

package/dist/engine/modules/relationship/endFlags.js

@@ -0,0 +1,32 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, StartRelationshipType } from "../../../constants/schema.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { bHas } from "../../../utils/bit.js";
+//#region src/engine/modules/relationship/endFlags.ts
+function selectEndColumns(collections, hasTable, { end }) {
+	if (!hasTable(end.tableId)) return [];
+	const table = query(collections).collection("tableEntities").selectById(end.tableId);
+	if (!table) return [];
+	const has = arrayHas(table.columnIds);
+	return query(collections).collection("tableColumnEntities").selectByIds(end.columnIds).filter((column) => has(column.id));
+}
+function* endColumnsOf({ doc, collections }) {
+	const hasTable = arrayHas(doc.tableIds);
+	const hasRelationship = arrayHas(doc.relationshipIds);
+	const relationships = query(collections).collection("relationshipEntities").selectAll();
+	for (const relationship of relationships) yield [relationship, hasRelationship(relationship.id) ? selectEndColumns(collections, hasTable, relationship) : []];
+}
+function recalculateIdentification(state) {
+	for (const [relationship, columns] of endColumnsOf(state)) {
+		const value = columns.length !== 0 && columns.every((column) => bHas(column.options, ColumnOption.primaryKey));
+		if (value !== relationship.identification) relationship.identification = value;
+	}
+}
+function recalculateStartRelationshipType(state) {
+	for (const [relationship, columns] of endColumnsOf(state)) {
+		const value = columns.every((column) => bHas(column.options, ColumnOption.notNull)) ? StartRelationshipType.dash : StartRelationshipType.ring;
+		if (value !== relationship.startRelationshipType) relationship.startRelationshipType = value;
+	}
+}
+//#endregion
+export { recalculateIdentification, recalculateStartRelationshipType };

package/dist/engine/modules/relationship/fkColumns.js

@@ -0,0 +1,85 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../../constants/schema.js";
+import { isListed } from "../dictionary/membership.js";
+import { addColumnAction, changeColumnCommentAction, changeColumnDataTypeAction, changeColumnDefaultAction, changeColumnDomainAction, changeColumnLogicalNameAction, changeColumnNameAction, changeColumnNotNullAction } from "../table-column/atom.actions.js";
+import { toReferenceDataType } from "./referenceType.js";
+import { bHas } from "../../../utils/bit.js";
+//#region src/engine/modules/relationship/fkColumns.ts
+var SEPARATOR = "_";
+var getStartKeyColumns = (collections, startTable) => query(collections).collection("tableColumnEntities").selectByIds(startTable.columnIds).filter(({ options }) => bHas(options, ColumnOption.primaryKey));
+var toNameKey = (name) => name.trim().toLowerCase();
+var WORD_CHARACTERS = /^[\p{L}\p{M}\p{N}]+$/u;
+var CASE_BOUNDARY = /\p{Ll}\p{Lu}|\p{Lu}\p{Lu}\p{Ll}|[\p{Lo}\p{Lm}][\p{Lu}\p{Ll}]|[\p{Lu}\p{Ll}][\p{Lo}\p{Lm}]/u;
+var MARKS_AND_DIGITS = /[\p{M}\p{N}]/gu;
+var isSingleWord = (name) => WORD_CHARACTERS.test(name) && !CASE_BOUNDARY.test(name.replace(MARKS_AND_DIGITS, ""));
+function prefixKeyName(tableName, keyName) {
+	const table = tableName.trim();
+	const key = keyName.trim();
+	if (!table || !isSingleWord(key) || toNameKey(key) === toNameKey(table)) return key;
+	return `${table}${SEPARATOR}${key}`;
+}
+function claimName(base, taken) {
+	let name = base;
+	for (let suffix = 2; taken.has(toNameKey(name)); suffix++) name = `${base}${SEPARATOR}${suffix}`;
+	taken.add(toNameKey(name));
+	return name;
+}
+function toForeignKeyNames(startTableName, keyNames, endColumnNames) {
+	const taken = new Set(endColumnNames.map(toNameKey).filter(Boolean));
+	const bases = keyNames.map((keyName) => prefixKeyName(startTableName, keyName));
+	const isKept = (index) => bases[index] === keyNames[index].trim();
+	const indexes = bases.map((_, index) => index);
+	const clashing = [...indexes.filter(isKept), ...indexes.filter((index) => !isKept(index))].filter((index) => {
+		const key = toNameKey(bases[index]);
+		const clashes = taken.has(key);
+		if (key) taken.add(key);
+		return clashes;
+	});
+	const names = [...bases];
+	for (const index of clashing) names[index] = claimName(bases[index], taken);
+	return names;
+}
+var toForeignKeyActions = (startColumns, endTableId, endColumnIds, { startTableName, endColumnNames, database, domainIds = [] }) => {
+	const names = toForeignKeyNames(startTableName, startColumns.map(({ name }) => name), endColumnNames);
+	return startColumns.flatMap((startColumn, index) => {
+		const payload = {
+			id: endColumnIds[index],
+			tableId: endTableId
+		};
+		const dataType = toReferenceDataType(startColumn.dataType, database);
+		const domainId = dataType === startColumn.dataType && isListed(domainIds, startColumn.domainId) ? startColumn.domainId : "";
+		return [
+			addColumnAction(payload),
+			changeColumnNotNullAction({
+				...payload,
+				value: true
+			}),
+			changeColumnNameAction({
+				...payload,
+				value: names[index]
+			}),
+			changeColumnDataTypeAction({
+				...payload,
+				value: dataType
+			}),
+			changeColumnDefaultAction({
+				...payload,
+				value: startColumn.default
+			}),
+			changeColumnCommentAction({
+				...payload,
+				value: startColumn.comment
+			}),
+			...startColumn.logicalName ? [changeColumnLogicalNameAction({
+				...payload,
+				value: startColumn.logicalName
+			})] : [],
+			...domainId ? [changeColumnDomainAction({
+				...payload,
+				value: domainId
+			})] : []
+		];
+	});
+};
+//#endregion
+export { getStartKeyColumns, isSingleWord, prefixKeyName, toForeignKeyActions, toForeignKeyNames, toNameKey };

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

@@ -0,0 +1,52 @@
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../../../constants/schema.js";
+import { createColumn } from "../../../utils/collection/tableColumn.entity.js";
+import { addColumnAction, changeColumnPrimaryKeyAction } from "../table-column/atom.actions.js";
+import { bHas } from "../../../utils/bit.js";
+import { addRelationshipAction } from "./atom.actions.js";
+import { toForeignKeyActions } from "./fkColumns.js";
+//#region src/engine/modules/relationship/generator.actions.ts
+var addRelationshipAction$ = (startTableId, endTableId, relationshipType, referentialActions = {}) => function* ({ doc: { tableIds, domainIds }, collections, settings: { database } }) {
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds);
+	const startTable = tables.find(({ id }) => id === startTableId);
+	const endTable = tables.find(({ id }) => id === endTableId);
+	if (!startTable || !endTable) return;
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const primaryKeys = columnCollection.selectByIds(startTable.columnIds).filter(({ options }) => bHas(options, ColumnOption.primaryKey));
+	const newPrimaryKey = primaryKeys.length ? null : createColumn({ tableId: startTable.id });
+	const startColumns = newPrimaryKey ? [newPrimaryKey] : primaryKeys;
+	const endColumnIds = startColumns.map(() => uuid25());
+	yield [
+		...newPrimaryKey ? [addColumnAction({
+			id: newPrimaryKey.id,
+			tableId: startTable.id
+		}), changeColumnPrimaryKeyAction({
+			id: newPrimaryKey.id,
+			tableId: startTable.id,
+			value: true
+		})] : [],
+		...toForeignKeyActions(startColumns, endTable.id, endColumnIds, {
+			startTableName: startTable.name,
+			endColumnNames: columnCollection.selectByIds(endTable.columnIds).map(({ name }) => name),
+			database,
+			domainIds
+		}),
+		addRelationshipAction({
+			id: uuid25(),
+			relationshipType,
+			...referentialActions,
+			start: {
+				tableId: startTable.id,
+				columnIds: startColumns.map(({ id }) => id)
+			},
+			end: {
+				tableId: endTable.id,
+				columnIds: endColumnIds
+			}
+		})
+	];
+};
+var actions$ = { addRelationshipAction$ };
+//#endregion
+export { actions$, addRelationshipAction$ };

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

@@ -0,0 +1,72 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { ActionType } from "./actions.js";
+import { addRelationshipAction, changeRelationshipColumnsAction, changeRelationshipOnDeleteAction, changeRelationshipOnUpdateAction, changeRelationshipTypeAction, namesOtherTables, removeRelationshipAction } from "./atom.actions.js";
+import { pick } from "es-toolkit";
+//#region src/engine/modules/relationship/history.ts
+var addRelationship = (undoActions, { payload: { id } }) => {
+	undoActions.push(removeRelationshipAction({ id }));
+};
+var removeRelationship = (undoActions, { payload: { id } }, { collections }) => {
+	const relationship = query(collections).collection("relationshipEntities").selectById(id);
+	if (!relationship) return;
+	undoActions.push(addRelationshipAction({
+		id: relationship.id,
+		relationshipType: relationship.relationshipType,
+		onDelete: relationship.onDelete,
+		onUpdate: relationship.onUpdate,
+		start: pick(relationship.start, ["tableId", "columnIds"]),
+		end: pick(relationship.end, ["tableId", "columnIds"])
+	}));
+};
+var changeRelationshipType = (undoActions, { payload: { id } }, { collections }) => {
+	const relationship = query(collections).collection("relationshipEntities").selectById(id);
+	if (!relationship) return;
+	undoActions.push(changeRelationshipTypeAction({
+		id,
+		value: relationship.relationshipType
+	}));
+};
+var changeRelationshipOnDelete = (undoActions, { payload: { id } }, { collections }) => {
+	const relationship = query(collections).collection("relationshipEntities").selectById(id);
+	if (!relationship) return;
+	undoActions.push(changeRelationshipOnDeleteAction({
+		id,
+		value: relationship.onDelete
+	}));
+};
+var changeRelationshipOnUpdate = (undoActions, { payload: { id } }, { collections }) => {
+	const relationship = query(collections).collection("relationshipEntities").selectById(id);
+	if (!relationship) return;
+	undoActions.push(changeRelationshipOnUpdateAction({
+		id,
+		value: relationship.onUpdate
+	}));
+};
+var changeRelationshipColumns = (undoActions, { payload: { id, start, end } }, { collections }) => {
+	const relationship = query(collections).collection("relationshipEntities").selectById(id);
+	if (!relationship || namesOtherTables(relationship, {
+		start,
+		end
+	})) return;
+	undoActions.push(changeRelationshipColumnsAction({
+		id,
+		start: {
+			tableId: relationship.start.tableId,
+			columnIds: [...relationship.start.columnIds]
+		},
+		end: {
+			tableId: relationship.end.tableId,
+			columnIds: [...relationship.end.columnIds]
+		}
+	}));
+};
+var relationshipPushUndoHistoryMap = {
+	[ActionType.addRelationship]: addRelationship,
+	[ActionType.removeRelationship]: removeRelationship,
+	[ActionType.changeRelationshipType]: changeRelationshipType,
+	[ActionType.changeRelationshipOnDelete]: changeRelationshipOnDelete,
+	[ActionType.changeRelationshipOnUpdate]: changeRelationshipOnUpdate,
+	[ActionType.changeRelationshipColumns]: changeRelationshipColumns
+};
+//#endregion
+export { relationshipPushUndoHistoryMap };

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

@@ -0,0 +1,250 @@
+import { LockSettingType, NameViewMode, Show } from "../../../constants/schema.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { DictionaryKind } from "../dictionary/actions.js";
+import { addColumnAction, changeColumnCommentAction, changeColumnDataTypeAction, changeColumnDefaultAction, changeColumnDomainAction, changeColumnLogicalNameAction, changeColumnNameAction, changeColumnNotNullAction, changeColumnPrimaryKeyAction, moveColumnAction, removeColumnAction } from "../table-column/atom.actions.js";
+import { addDictionaryAction, removeDictionaryAction, updateDictionaryAction } from "../dictionary/atom.actions.js";
+import { ViewKind } from "../editor/state.js";
+import { bHas } from "../../../utils/bit.js";
+import { getActiveView, isViewShown } from "../editor/view.js";
+import { viewChangeShowModeAction, viewChangeZoomLevelAction, viewCloseAction, viewMoveTableAction, viewOpenAction, viewScrollToAction, viewSetCentersAction, viewSetLayoutAction, viewStepCentersAction, viewStreamScrollToAction, viewStreamZoomLevelAction } from "../editor/view.actions.js";
+import { Tag } from "../../tag.js";
+import { getVisibleIds } from "../../../konva/scene/viewLayout.js";
+import { invalidateTableWidths } from "../../../utils/calcTable.js";
+import { changeLockSettingsAction, changeMaxWidthCommentAction, changeNameViewModeAction, changeShowAction } from "../settings/atom.actions.js";
+import { recalculateIdentification, recalculateStartRelationshipType } from "./endFlags.js";
+import { relationshipSort } from "../../../utils/draw-relationship/sort.js";
+import { addIndexAction, changeIndexUniqueAction, removeIndexAction } from "../index/atom.actions.js";
+import { addIndexColumnAction, moveIndexColumnAction, removeIndexColumnAction } from "../index-column/atom.actions.js";
+import { moveMemoAction } from "../memo/atom.actions.js";
+import { addRelationshipAction, changeRelationshipColumnsAction, removeRelationshipAction } from "./atom.actions.js";
+import { addTableAction, changeTableCommentAction, changeTableLogicalNameAction, changeTableNameAction, moveTableAction, moveToTableAction, removeTableAction, sortTableAction } from "../table/atom.actions.js";
+import { isNil, isString } from "es-toolkit";
+import { asapScheduler, filter, observeOn, tap, throttle, timer } from "rxjs";
+//#region src/engine/modules/relationship/hooks.ts
+var identificationHook = (action$, getState) => action$.pipe(throttle(() => timer(0, asapScheduler), {
+	leading: false,
+	trailing: true
+})).subscribe(() => recalculateIdentification(getState()));
+var startRelationshipHook = (action$, getState) => action$.pipe(throttle(() => timer(0, asapScheduler), {
+	leading: false,
+	trailing: true
+}), observeOn(asapScheduler)).subscribe(() => recalculateStartRelationshipType(getState()));
+var isMoveOnly = arrayHas([
+	moveTableAction.type,
+	moveToTableAction.type,
+	moveMemoAction.type
+]);
+var sortWindow = ({ tags }) => !isNil(tags) && bHas(tags, Tag.drag) ? timer(5) : timer(0, asapScheduler);
+var alternateKeyActions = [
+	addIndexAction,
+	removeIndexAction,
+	changeIndexUniqueAction,
+	addIndexColumnAction,
+	removeIndexColumnAction,
+	moveIndexColumnAction,
+	moveColumnAction
+];
+var alternateKeyActionTypes = alternateKeyActions.map((action) => action.type);
+var isAlternateKeyAction = arrayHas(alternateKeyActionTypes);
+var isPaintOnlyShow = arrayHas([
+	Show.hideReferentialAction,
+	Show.hideTableGroup,
+	Show.hideMemo
+]);
+var isPaintOnlyToggle = (action) => action.type === changeShowAction.type && isPaintOnlyShow(action.payload?.show);
+var isDictionaryWrite = arrayHas([
+	addDictionaryAction.type,
+	updateDictionaryAction.type,
+	removeDictionaryAction.type
+]);
+var reachesLayout = ({ type, payload }, state) => {
+	if (type === changeNameViewModeAction.type) return payload.shared === true || payload.editorId === state.editor.id;
+	if (isDictionaryWrite(type)) return payload?.kind === DictionaryKind.domain && (type !== updateDictionaryAction.type || isString(payload.values?.name));
+	if (type === changeLockSettingsAction.type) return payload?.value === false && bHas(payload.lockSettingType, LockSettingType.unlockNameViewMode);
+	return true;
+};
+var relationshipSortHook = (action$, getState, ctx) => action$.pipe(filter((action) => (!isAlternateKeyAction(action.type) || bHas(getState().settings.show, Show.columnAlternateKey)) && !isPaintOnlyToggle(action) && reachesLayout(action, getState())), tap((action) => {
+	if (!isMoveOnly(action.type)) invalidateTableWidths();
+}), throttle(sortWindow, {
+	leading: false,
+	trailing: true
+})).subscribe(() => {
+	relationshipSort(getState(), "document", { route: ctx.routes !== false });
+});
+var isDocumentOnly = arrayHas([
+	changeShowAction.type,
+	changeMaxWidthCommentAction.type,
+	moveMemoAction.type,
+	...alternateKeyActionTypes
+]);
+var isNameViewOnly = arrayHas([
+	changeTableLogicalNameAction.type,
+	changeColumnLogicalNameAction.type,
+	changeColumnDomainAction.type,
+	addDictionaryAction.type,
+	updateDictionaryAction.type,
+	removeDictionaryAction.type
+]);
+var isViewTransform = arrayHas([
+	viewScrollToAction.type,
+	viewStreamScrollToAction.type,
+	viewChangeZoomLevelAction.type,
+	viewStreamZoomLevelAction.type
+]);
+var idOf = ({ id }) => [id];
+var idsOf = ({ ids }) => ids;
+var tableIdOf = ({ tableId }) => [tableId];
+var kindOf = (_, { kind }) => kind;
+var flowOnly = () => ViewKind.flow;
+var namedOrActiveKind = (state, { kind }) => kind ?? getActiveView(state)?.kind ?? null;
+var aimedKind = {
+	[viewOpenAction.type]: kindOf,
+	[viewCloseAction.type]: kindOf,
+	[viewSetLayoutAction.type]: kindOf,
+	[viewSetCentersAction.type]: flowOnly,
+	[viewStepCentersAction.type]: flowOnly,
+	[viewChangeShowModeAction.type]: namedOrActiveKind,
+	[viewMoveTableAction.type]: namedOrActiveKind
+};
+var namedIds = {
+	[addTableAction.type]: idOf,
+	[removeTableAction.type]: idOf,
+	[moveToTableAction.type]: idOf,
+	[changeTableNameAction.type]: idOf,
+	[changeTableLogicalNameAction.type]: idOf,
+	[changeTableCommentAction.type]: idOf,
+	[addRelationshipAction.type]: idOf,
+	[removeRelationshipAction.type]: idOf,
+	[changeRelationshipColumnsAction.type]: ({ id, start, end }) => [
+		id,
+		start.tableId,
+		end.tableId
+	],
+	[moveTableAction.type]: idsOf,
+	[viewMoveTableAction.type]: idsOf,
+	[addColumnAction.type]: tableIdOf,
+	[removeColumnAction.type]: tableIdOf,
+	[changeColumnNameAction.type]: tableIdOf,
+	[changeColumnLogicalNameAction.type]: tableIdOf,
+	[changeColumnDomainAction.type]: tableIdOf,
+	[changeColumnCommentAction.type]: tableIdOf,
+	[changeColumnDataTypeAction.type]: tableIdOf,
+	[changeColumnDefaultAction.type]: tableIdOf,
+	[changeColumnPrimaryKeyAction.type]: tableIdOf
+};
+function shownIds(state, source) {
+	const { tableIds, relationshipIds } = getVisibleIds(state, source);
+	return /* @__PURE__ */ new Set([...tableIds, ...relationshipIds]);
+}
+function touchesView(state, action, lastRead, source) {
+	if (isDocumentOnly(action.type) || isViewTransform(action.type)) return false;
+	if (isNameViewOnly(action.type) && state.settings.nameViewMode === NameViewMode.physical) return false;
+	const aimed = aimedKind[action.type];
+	if (aimed && aimed(state, action.payload) !== source) return false;
+	const named = namedIds[action.type];
+	if (!named) return true;
+	const shown = shownIds(state, source);
+	return named(action.payload).some((id) => shown.has(id) || lastRead.has(id));
+}
+var VIEW_SOURCES = [ViewKind.flow];
+var viewRelationshipSortHook = (action$, getState) => {
+	const lastRead = { flow: /* @__PURE__ */ new Set() };
+	const pending = /* @__PURE__ */ new Set();
+	return action$.pipe(filter((action) => {
+		const state = getState();
+		if (!reachesLayout(action, state)) return false;
+		let touched = false;
+		for (const source of VIEW_SOURCES) if (isViewShown(state, source) && touchesView(state, action, lastRead[source], source)) {
+			pending.add(source);
+			touched = true;
+		}
+		return touched;
+	}), throttle(sortWindow, {
+		leading: false,
+		trailing: true
+	})).subscribe(() => {
+		const state = getState();
+		const sources = [...pending];
+		pending.clear();
+		for (const source of sources) {
+			if (!isViewShown(state, source)) continue;
+			relationshipSort(state, source);
+			lastRead[source] = shownIds(state, source);
+		}
+	});
+};
+var layoutActions = [
+	changeShowAction,
+	changeMaxWidthCommentAction,
+	addRelationshipAction,
+	removeRelationshipAction,
+	changeRelationshipColumnsAction,
+	moveMemoAction,
+	addTableAction,
+	removeTableAction,
+	moveTableAction,
+	moveToTableAction,
+	changeTableNameAction,
+	changeTableCommentAction,
+	addColumnAction,
+	removeColumnAction,
+	changeColumnNameAction,
+	changeColumnCommentAction,
+	changeColumnDataTypeAction,
+	changeColumnDefaultAction,
+	sortTableAction,
+	...alternateKeyActions,
+	changeNameViewModeAction,
+	changeLockSettingsAction,
+	changeTableLogicalNameAction,
+	changeColumnLogicalNameAction,
+	changeColumnDomainAction,
+	addDictionaryAction,
+	updateDictionaryAction,
+	removeDictionaryAction
+];
+var viewRowActions = [changeColumnPrimaryKeyAction];
+var viewLayoutActions = [
+	viewOpenAction,
+	viewCloseAction,
+	viewScrollToAction,
+	viewStreamScrollToAction,
+	viewChangeZoomLevelAction,
+	viewStreamZoomLevelAction,
+	viewMoveTableAction,
+	viewSetLayoutAction,
+	viewChangeShowModeAction,
+	viewSetCentersAction,
+	viewStepCentersAction
+];
+var hooks = [
+	[[
+		addColumnAction,
+		removeColumnAction,
+		changeColumnPrimaryKeyAction,
+		addRelationshipAction,
+		removeRelationshipAction,
+		changeRelationshipColumnsAction,
+		addTableAction,
+		removeTableAction
+	], identificationHook],
+	[[
+		addColumnAction,
+		removeColumnAction,
+		changeColumnNotNullAction,
+		changeColumnPrimaryKeyAction,
+		addRelationshipAction,
+		removeRelationshipAction,
+		changeRelationshipColumnsAction,
+		addTableAction,
+		removeTableAction
+	], startRelationshipHook],
+	[layoutActions, relationshipSortHook],
+	[[
+		...layoutActions,
+		...viewRowActions,
+		...viewLayoutActions
+	], viewRelationshipSortHook]
+];
+//#endregion
+export { hooks };

package/dist/engine/modules/relationship/referenceType.js

@@ -0,0 +1,29 @@
+import { Database } from "../../../constants/schema.js";
+//#region src/engine/modules/relationship/referenceType.ts
+var SERIAL = "serial";
+var POSTGRESQL_SERIALS = /* @__PURE__ */ new Map([
+	["smallserial", "smallint"],
+	["serial2", "smallint"],
+	["serial4", "integer"],
+	["bigserial", "bigint"],
+	["serial8", "bigint"]
+]);
+var SERIAL_BY_DATABASE = /* @__PURE__ */ new Map([
+	[Database.PostgreSQL, "integer"],
+	[Database.MySQL, "bigint unsigned"],
+	[Database.MariaDB, "bigint unsigned"]
+]);
+var toTypeKey = (dataType) => dataType.trim().toLowerCase();
+function isSerialType(dataType) {
+	const key = toTypeKey(dataType);
+	return key === SERIAL || POSTGRESQL_SERIALS.has(key);
+}
+function toReferenceDataType(dataType, database) {
+	const key = toTypeKey(dataType);
+	const reference = key === SERIAL ? SERIAL_BY_DATABASE.get(database) : POSTGRESQL_SERIALS.get(key);
+	if (!reference) return dataType;
+	const name = dataType.trim();
+	return name === name.toUpperCase() ? reference.toUpperCase() : reference;
+}
+//#endregion
+export { isSerialType, toReferenceDataType };

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

@@ -0,0 +1,24 @@
+//#region src/engine/modules/settings/actions.ts
+var ActionType = {
+	changeDatabaseName: "settings.changeDatabaseName",
+	changeZoomLevel: "settings.changeZoomLevel",
+	streamZoomLevel: "settings.streamZoomLevel",
+	scrollTo: "settings.scrollTo",
+	streamScrollTo: "settings.streamScrollTo",
+	changeShow: "settings.changeShow",
+	changeDatabase: "settings.changeDatabase",
+	changeCanvasType: "settings.changeCanvasType",
+	changeLanguage: "settings.changeLanguage",
+	changeTableNameCase: "settings.changeTableNameCase",
+	changeColumnNameCase: "settings.changeColumnNameCase",
+	changeBracketType: "settings.changeBracketType",
+	changeRelationshipDataTypeSync: "settings.changeRelationshipDataTypeSync",
+	changeColumnOrder: "settings.changeColumnOrder",
+	changeMaxWidthComment: "settings.changeMaxWidthComment",
+	changeLockSettings: "settings.changeLockSettings",
+	changeIgnoreSaveSettings: "settings.changeIgnoreSaveSettings",
+	changeDDLScript: "settings.changeDDLScript",
+	changeNameViewMode: "settings.changeNameViewMode"
+};
+//#endregion
+export { ActionType };

package/dist/engine/modules/settings/atom.actions.d.ts

@@ -269,7 +269,7 @@ export declare const toNameViewModeAction: (state: RootState, value: NameViewMod
  * its register, a bit no lock owns taken from the load as show is, and each
  * setting locked once it lands but the view keeping the screen.
  */
-export declare function landLoadedSettings({ settings, lww }: RootState, loaded: RootState['settings'], version: number): void;
+export declare function landLoadedSettings(state: RootState, loaded: RootState['settings'], version: number, tags?: number): void;
 export declare const settingsReducers: {
     "settings.changeDatabaseName": ReducerType<"settings.changeDatabaseName">;
     "settings.changeZoomLevel": ReducerType<"settings.changeZoomLevel">;