@dineug/erd-editor 4.2.0 → 5.0.1

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

@@ -0,0 +1,324 @@
+import { isSettingLocked, setSettingLock } from "../../../erd-editor-schema/dist/v3/schema/settings.js";
+import { replaceOperator } from "../../../erd-editor-schema/dist/query/lww.js";
+import { CanvasType, DDLScriptPositionList, LockSettingFields, LockSettingType, LockSettingTypeList, Show } from "../../../constants/schema.js";
+import { hasBracketType, hasCanvasType, hasColumnType, hasDatabase, hasLanguage, hasNameCase, hasNameViewMode, maxWidthCommentInRange, zoomInRange, zoomLevelInRange } from "../../../utils/validation.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { bHas } from "../../../utils/bit.js";
+import { keepFocusShown } from "../editor/utils/nameView.js";
+import { releaseMemos, releaseTableGroups } from "../editor/utils/releaseHidden.js";
+import { viewScrollToAction, viewStreamScrollToAction } from "../editor/view.actions.js";
+import { Tag } from "../../tag.js";
+import { getSceneTransform } from "../../../konva/scene/viewport.js";
+import { getFrozenOrigin, getViewContentRect } from "../../../konva/scene/viewFreeze.js";
+import { ActionType } from "./actions.js";
+import { endScreenBaseline, isScreenWrite, keepScreenBaseline, landScreenBaseline, settingWriteTarget, viewportWriteTarget } from "./screenBaseline.js";
+import { contentScrollRange, openingOrigin } from "./scrollRange.js";
+import { clamp, isNil, isNumber, isString, pick } from "es-toolkit";
+import { round } from "es-toolkit/compat";
+//#region src/engine/modules/settings/atom.actions.ts
+var changeDatabaseNameAction = createAction(ActionType.changeDatabaseName);
+var changeDatabaseName = ({ settings, lww }, { payload: { value }, version }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	replaceOperator(lww, safeVersion, "settings.databaseName", "settings", "databaseName", () => {
+		settings.databaseName = value;
+	});
+};
+var changeZoomLevelAction = createAction(ActionType.changeZoomLevel);
+var changeZoomLevel = (state, { payload: { value }, tags }) => {
+	if (!isNil(tags) && bHas(tags, Tag.following)) return;
+	viewportWriteTarget(state, tags).zoomLevel = zoomLevelInRange(value);
+};
+var streamZoomLevelAction = createAction(ActionType.streamZoomLevel);
+var streamZoomLevel = (state, { payload: { value }, tags }) => {
+	if (!isNil(tags) && bHas(tags, Tag.following)) return;
+	const target = viewportWriteTarget(state, tags);
+	target.zoomLevel = zoomLevelInRange(target.zoomLevel + value);
+};
+var still = (origin) => ({
+	min: origin,
+	max: origin
+});
+var hasViewport = ({ width, height }) => width > 0 && height > 0;
+function getContentScrollRanges(state, source = "document") {
+	const { originX, originY, zoomLevel } = getSceneTransform(state, source);
+	const { viewport } = state.editor;
+	const content = getViewContentRect(state, source);
+	if (!content || !hasViewport(viewport)) return {
+		left: still(originX),
+		top: still(originY)
+	};
+	return {
+		left: contentScrollRange(content.x, content.x + content.width, viewport.width, zoomLevel),
+		top: contentScrollRange(content.y, content.y + content.height, viewport.height, zoomLevel)
+	};
+}
+function getOpeningOrigin(state) {
+	const { settings: { originX, originY, zoomLevel }, editor: { viewport } } = state;
+	const content = getViewContentRect(state);
+	if (!content || !hasViewport(viewport)) return {
+		x: originX,
+		y: originY
+	};
+	return {
+		x: openingOrigin(originX, content.x, content.x + content.width, viewport.width, zoomLevel),
+		y: openingOrigin(originY, content.y, content.y + content.height, viewport.height, zoomLevel)
+	};
+}
+var hull = (range, ...origins) => ({
+	min: Math.min(range.min, ...origins),
+	max: Math.max(range.max, ...origins)
+});
+function getScrollRanges(state, source = "document") {
+	const { originX, originY } = getSceneTransform(state, source);
+	const { left, top } = getContentScrollRanges(state, source);
+	const anchor = getFrozenOrigin(state, source);
+	return anchor ? {
+		left: hull(left, originX, anchor.x),
+		top: hull(top, originY, anchor.y)
+	} : {
+		left: hull(left, originX),
+		top: hull(top, originY)
+	};
+}
+function clampScrollMovement(state, { movementX, movementY }, source = "document") {
+	if (!hasViewport(state.editor.viewport)) return {
+		movementX,
+		movementY
+	};
+	const { originX, originY } = getSceneTransform(state, source);
+	const { left, top } = getScrollRanges(state, source);
+	return {
+		movementX: clamp(originX + movementX, left.min, left.max) - originX,
+		movementY: clamp(originY + movementY, top.min, top.max) - originY
+	};
+}
+var scrollToAction = createAction(ActionType.scrollTo);
+var scrollTo = (state, { payload: { originX, originY }, tags }) => {
+	if (!isNil(tags) && bHas(tags, Tag.following)) return;
+	const target = viewportWriteTarget(state, tags);
+	target.originX = round(originX, 4);
+	target.originY = round(originY, 4);
+};
+var streamScrollToAction = createAction(ActionType.streamScrollTo);
+var streamScrollTo = (state, { payload: { movementX, movementY }, tags }) => {
+	if (!isNil(tags) && bHas(tags, Tag.following)) return;
+	const target = viewportWriteTarget(state, tags);
+	target.originX = round(target.originX + movementX, 4);
+	target.originY = round(target.originY + movementY, 4);
+};
+var sceneScrollToAction = (source, payload) => source === "document" ? scrollToAction(payload) : viewScrollToAction({
+	...payload,
+	kind: source
+});
+var sceneStreamScrollToAction = (source, payload) => source === "document" ? streamScrollToAction(payload) : viewStreamScrollToAction({
+	...payload,
+	kind: source
+});
+var changeShowAction = createAction(ActionType.changeShow);
+var changeShow = (state, { payload: { show, value }, tags }) => {
+	const target = settingWriteTarget(state, tags, "show");
+	const bits = target.show ?? 0;
+	target.show = value ? bits | show : bits & ~show;
+	if (target !== state.settings) return;
+	if (value && bHas(show, Show.hideTableGroup)) releaseTableGroups(state);
+	if (value && bHas(show, Show.hideMemo)) releaseMemos(state);
+	if (bHas(show, Show.columnDomain)) keepFocusShown(state);
+};
+var changeDatabaseAction = createAction(ActionType.changeDatabase);
+var changeDatabase = (state, { payload: { value }, tags }) => {
+	if (hasDatabase(value)) settingWriteTarget(state, tags, "database").database = value;
+};
+function rememberCanvasType({ settings, editor }) {
+	if (settings.canvasType !== CanvasType.settings) editor.lastCanvasType = settings.canvasType;
+}
+var changeCanvasTypeAction = createAction(ActionType.changeCanvasType);
+var changeCanvasType = (state, { payload: { value }, tags }) => {
+	if (!isNil(tags) && bHas(tags, Tag.following)) return;
+	const target = settingWriteTarget(state, tags, "canvasType");
+	if (target !== state.settings) {
+		target.canvasType = value;
+		return;
+	}
+	rememberCanvasType(state);
+	state.settings.canvasType = value;
+	if (value !== CanvasType.ERD) state.editor.drawTableGroup = false;
+};
+function replaceCodeSetting(state, version, field, value, tags) {
+	const target = settingWriteTarget(state, tags, field);
+	const write = () => {
+		target[field] = value;
+	};
+	if (isScreenWrite(tags)) return write();
+	replaceOperator(state.lww, version, "settings.code", "settings", field, write);
+}
+var changeLanguageAction = createAction(ActionType.changeLanguage);
+var changeLanguage = (state, { payload: { value }, version, tags }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	if (hasLanguage(value)) replaceCodeSetting(state, safeVersion, "language", value, tags);
+};
+var changeTableNameCaseAction = createAction(ActionType.changeTableNameCase);
+var changeTableNameCase = (state, { payload: { value }, version, tags }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	if (hasNameCase(value)) replaceCodeSetting(state, safeVersion, "tableNameCase", value, tags);
+};
+var changeColumnNameCaseAction = createAction(ActionType.changeColumnNameCase);
+var changeColumnNameCase = (state, { payload: { value }, version, tags }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	if (hasNameCase(value)) replaceCodeSetting(state, safeVersion, "columnNameCase", value, tags);
+};
+var changeBracketTypeAction = createAction(ActionType.changeBracketType);
+var changeBracketType = (state, { payload: { value }, version, tags }, { clock }) => {
+	const safeVersion = version ?? clock.getVersion();
+	if (hasBracketType(value)) replaceCodeSetting(state, safeVersion, "bracketType", value, tags);
+};
+var changeRelationshipDataTypeSyncAction = createAction(ActionType.changeRelationshipDataTypeSync);
+var changeRelationshipDataTypeSync = ({ settings }, { payload: { value } }) => {
+	settings.relationshipDataTypeSync = value;
+};
+var changeColumnOrderAction = createAction(ActionType.changeColumnOrder);
+var changeColumnOrder = ({ settings }, { payload: { value, target } }) => {
+	if (value === target || !hasColumnType(value) || !hasColumnType(target)) return;
+	const index = settings.columnOrder.indexOf(value);
+	const targetIndex = settings.columnOrder.indexOf(target);
+	if (index === -1 || targetIndex === -1) return;
+	settings.columnOrder.splice(index, 1);
+	settings.columnOrder.splice(targetIndex, 0, value);
+};
+var changeMaxWidthCommentAction = createAction(ActionType.changeMaxWidthComment);
+var changeMaxWidthComment = ({ settings }, { payload: { value } }) => {
+	settings.maxWidthComment = value === -1 ? value : maxWidthCommentInRange(value);
+};
+var changeLockSettingsAction = createAction(ActionType.changeLockSettings);
+var isLockedValue = {
+	originX: Number.isFinite,
+	originY: Number.isFinite,
+	zoomLevel: (value) => isNumber(value) && zoomInRange(value) === value,
+	canvasType: (value) => hasCanvasType(value) && value !== CanvasType.settings,
+	language: hasLanguage,
+	tableNameCase: hasNameCase,
+	columnNameCase: hasNameCase,
+	bracketType: hasBracketType,
+	nameViewMode: hasNameViewMode
+};
+var CodeLockSettings = LockSettingType.language | LockSettingType.tableNameCase | LockSettingType.columnNameCase | LockSettingType.bracketType;
+var UnlockCarriedSettings = CodeLockSettings | LockSettingType.unlockNameViewMode;
+var changeLockSettings = (state, { payload: { lockSettingType, value, values }, version, tags }, { clock }) => {
+	const { settings, lww } = state;
+	const safeVersion = version ?? clock.getVersion();
+	LockSettingTypeList.forEach((bit) => {
+		if (!bHas(lockSettingType, bit)) return;
+		const fields = LockSettingFields[bit];
+		const carried = pick(values, fields);
+		const valid = fields.filter((field) => isLockedValue[field](carried[field]));
+		if (value && valid.length < fields.length) return;
+		replaceOperator(lww, safeVersion, "settings.lockSettings", "settings", String(bit), () => {
+			if (value) Object.assign(settings.lockedValues, carried);
+			settings.lockSettings = setSettingLock(settings.lockSettings, bit, value);
+		});
+		if (value || !bHas(UnlockCarriedSettings, bit)) return;
+		valid.forEach((field) => field === "nameViewMode" ? replaceNameViewMode(state, safeVersion, carried.nameViewMode) : replaceCodeSetting(state, safeVersion, field, carried[field], tags));
+	});
+};
+var changeIgnoreSaveSettingsAction = createAction(ActionType.changeIgnoreSaveSettings);
+var changeIgnoreSaveSettings = () => {};
+var changeDDLScriptAction = createAction(ActionType.changeDDLScript);
+var changeDDLScript = ({ settings, lww }, { payload: { position, value }, version }, { clock }) => {
+	if (!DDLScriptPositionList.includes(position) || !isString(value)) return;
+	const safeVersion = version ?? clock.getVersion();
+	replaceOperator(lww, safeVersion, "settings.ddlScripts", "settings", position, () => {
+		settings.ddlScripts = {
+			...settings.ddlScripts,
+			[position]: value
+		};
+	});
+};
+function showNameViewMode(state, value) {
+	state.settings.nameViewMode = value;
+	keepFocusShown(state);
+}
+function replaceNameViewMode(state, version, value) {
+	replaceOperator(state.lww, version, "settings.nameViewMode", "settings", "nameViewMode", () => {
+		endScreenBaseline(state.editor, "nameViewMode");
+		showNameViewMode(state, value);
+	});
+}
+var changeNameViewModeAction = createAction(ActionType.changeNameViewMode);
+var changeNameViewMode = (state, { payload: { value, shared, editorId }, version, tags }, { clock }) => {
+	if (!hasNameViewMode(value)) return;
+	const screen = isScreenWrite(tags);
+	if (shared === true && !screen) {
+		replaceNameViewMode(state, version ?? clock.getVersion(), value);
+		return;
+	}
+	if (editorId !== state.editor.id) return;
+	if (screen) keepScreenBaseline(state, "nameViewMode");
+	else endScreenBaseline(state.editor, "nameViewMode");
+	showNameViewMode(state, value);
+};
+var toNameViewModeAction = (state, value, readonly) => changeNameViewModeAction({
+	value,
+	shared: !readonly && !isSettingLocked(state.settings.lockSettings, LockSettingType.unlockNameViewMode),
+	editorId: state.editor.id
+});
+var LOCK_KNOWN = LockSettingTypeList.reduce((acc, bit) => acc | bit, 0);
+function landLoadedSettings(state, loaded, version, tags) {
+	const { settings, lww } = state;
+	const { lockSettings, lockedValues, ...screen } = settings;
+	Object.assign(settings, loaded, {
+		lockSettings: lockSettings & LOCK_KNOWN | loaded.lockSettings & ~LOCK_KNOWN,
+		lockedValues: { ...lockedValues }
+	});
+	LockSettingTypeList.forEach((bit) => {
+		const fields = LockSettingFields[bit];
+		replaceOperator(lww, version, "settings.lockSettings", "settings", String(bit), () => {
+			settings.lockSettings = bHas(loaded.lockSettings, bit) ? settings.lockSettings | bit : settings.lockSettings & ~bit;
+			Object.assign(settings.lockedValues, pick(loaded.lockedValues, fields));
+		});
+		if (bit !== LockSettingType.viewport && isSettingLocked(settings.lockSettings, bit)) Object.assign(settings, pick(screen, fields));
+	});
+	landScreenBaseline(state, screen, tags);
+}
+var settingsReducers = {
+	[ActionType.changeDatabaseName]: changeDatabaseName,
+	[ActionType.changeZoomLevel]: changeZoomLevel,
+	[ActionType.streamZoomLevel]: streamZoomLevel,
+	[ActionType.scrollTo]: scrollTo,
+	[ActionType.streamScrollTo]: streamScrollTo,
+	[ActionType.changeShow]: changeShow,
+	[ActionType.changeDatabase]: changeDatabase,
+	[ActionType.changeCanvasType]: changeCanvasType,
+	[ActionType.changeLanguage]: changeLanguage,
+	[ActionType.changeTableNameCase]: changeTableNameCase,
+	[ActionType.changeColumnNameCase]: changeColumnNameCase,
+	[ActionType.changeBracketType]: changeBracketType,
+	[ActionType.changeRelationshipDataTypeSync]: changeRelationshipDataTypeSync,
+	[ActionType.changeColumnOrder]: changeColumnOrder,
+	[ActionType.changeMaxWidthComment]: changeMaxWidthComment,
+	[ActionType.changeLockSettings]: changeLockSettings,
+	[ActionType.changeIgnoreSaveSettings]: changeIgnoreSaveSettings,
+	[ActionType.changeDDLScript]: changeDDLScript,
+	[ActionType.changeNameViewMode]: changeNameViewMode
+};
+var actions = {
+	changeDatabaseNameAction,
+	changeZoomLevelAction,
+	streamZoomLevelAction,
+	scrollToAction,
+	streamScrollToAction,
+	changeShowAction,
+	changeDatabaseAction,
+	changeCanvasTypeAction,
+	changeLanguageAction,
+	changeTableNameCaseAction,
+	changeColumnNameCaseAction,
+	changeBracketTypeAction,
+	changeRelationshipDataTypeSyncAction,
+	changeColumnOrderAction,
+	changeMaxWidthCommentAction,
+	changeLockSettingsAction,
+	changeIgnoreSaveSettingsAction,
+	changeDDLScriptAction,
+	changeNameViewModeAction
+};
+//#endregion
+export { CodeLockSettings, UnlockCarriedSettings, actions, changeBracketTypeAction, changeCanvasTypeAction, changeColumnNameCaseAction, changeColumnOrderAction, changeDDLScriptAction, changeDatabaseAction, changeDatabaseNameAction, changeIgnoreSaveSettingsAction, changeLanguageAction, changeLockSettingsAction, changeMaxWidthCommentAction, changeNameViewModeAction, changeRelationshipDataTypeSyncAction, changeShowAction, changeTableNameCaseAction, changeZoomLevelAction, clampScrollMovement, getContentScrollRanges, getOpeningOrigin, getScrollRanges, hasViewport, landLoadedSettings, rememberCanvasType, sceneScrollToAction, sceneStreamScrollToAction, scrollToAction, settingsReducers, streamScrollToAction, streamZoomLevelAction, toNameViewModeAction };

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

@@ -24,6 +24,12 @@ export declare const pinchZoomAction$: ({ zoomLevel, screen, scene }: PinchZoom,
  * locked on the Settings tab holds the tab the reader came from.
  */
 export declare const changeLockSettingsAction$: (lockSettingType: number, value: boolean) => GeneratorAction;
+/**
+ * What a readonly editor turning writable sends in one batch: the document's
+ * code settings, database and show bits back on the screen through their own
+ * setters, tagged as the screen's, then the end of their baseline.
+ */
+export declare const restoreScreenSettingsAction$: () => GeneratorAction;
 export declare const actions$: {
     changeZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
     streamZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;

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

@@ -0,0 +1,132 @@
+import { CanvasType, LockSettingFields, LockSettingTypeList } from "../../../constants/schema.js";
+import { zoomLevelInRange } from "../../../utils/validation.js";
+import { bHas } from "../../../utils/bit.js";
+import { viewChangeZoomLevelAction, viewScrollToAction, viewStreamScrollToAction, viewStreamZoomLevelAction } from "../editor/view.actions.js";
+import { Tag, attachActionsTag } from "../../tag.js";
+import { getZoomTransform, toScenePoint, toScreenPoint } from "../../../konva/scene/viewport.js";
+import { UnlockCarriedSettings, changeBracketTypeAction, changeColumnNameCaseAction, changeDatabaseAction, changeLanguageAction, changeLockSettingsAction, changeShowAction, changeTableNameCaseAction, changeZoomLevelAction, scrollToAction, streamScrollToAction, streamZoomLevelAction } from "./atom.actions.js";
+import { endScreenSettingsAction } from "../editor/atom.actions.js";
+import { isNil, pick } from "es-toolkit";
+import { round } from "es-toolkit/compat";
+//#region src/engine/modules/settings/generator.actions.ts
+function getMovementToPlace(transform, nextZoomLevel, scene, screen) {
+	const landed = toScreenPoint({
+		...transform,
+		zoomLevel: nextZoomLevel
+	}, scene);
+	return {
+		movementX: round(screen.x - landed.x, 4),
+		movementY: round(screen.y - landed.y, 4)
+	};
+}
+function getMovementScrollTo(state, transform, nextZoomLevel) {
+	const { viewport } = state.editor;
+	const center = {
+		x: viewport.width / 2,
+		y: viewport.height / 2
+	};
+	return getMovementToPlace(transform, nextZoomLevel, toScenePoint(transform, center), center);
+}
+var changeZoomLevelAction$ = (value, source) => function* (state) {
+	const transform = getZoomTransform(state, source);
+	const { originX, originY } = transform;
+	const { movementX, movementY } = getMovementScrollTo(state, transform, zoomLevelInRange(value));
+	const origin = {
+		originX: originX + movementX,
+		originY: originY + movementY
+	};
+	if (source && source !== "document") {
+		yield viewChangeZoomLevelAction({
+			value,
+			kind: source
+		});
+		yield viewScrollToAction({
+			...origin,
+			kind: source
+		});
+		return;
+	}
+	yield changeZoomLevelAction({ value });
+	yield scrollToAction(origin);
+};
+var streamZoomLevelAction$ = (value, source) => function* (state) {
+	const transform = getZoomTransform(state, source);
+	const movement = getMovementScrollTo(state, transform, zoomLevelInRange(transform.zoomLevel + value));
+	if (source && source !== "document") {
+		yield viewStreamZoomLevelAction({
+			value,
+			kind: source
+		});
+		yield viewStreamScrollToAction({
+			...movement,
+			kind: source
+		});
+		return;
+	}
+	yield streamZoomLevelAction({ value });
+	yield streamScrollToAction(movement);
+};
+var pinchZoomAction$ = ({ zoomLevel, screen, scene }, source) => function* (state) {
+	const transform = getZoomTransform(state, source);
+	const nextZoomLevel = zoomLevelInRange(zoomLevel);
+	const value = round(nextZoomLevel - transform.zoomLevel, 2);
+	const movement = getMovementToPlace(transform, nextZoomLevel, scene ?? toScenePoint(transform, screen), screen);
+	const kind = source && source !== "document" ? source : null;
+	if (value !== 0) yield kind ? viewStreamZoomLevelAction({
+		value,
+		kind
+	}) : streamZoomLevelAction({ value });
+	if (movement.movementX !== 0 || movement.movementY !== 0) yield kind ? viewStreamScrollToAction({
+		...movement,
+		kind
+	}) : streamScrollToAction(movement);
+};
+var changeLockSettingsAction$ = (lockSettingType, value) => function* ({ settings, editor }) {
+	const named = value ? lockSettingType : lockSettingType & UnlockCarriedSettings;
+	const fields = LockSettingTypeList.filter((bit) => bHas(named, bit)).flatMap((bit) => LockSettingFields[bit]);
+	const values = pick(settings, fields);
+	if (values.canvasType === CanvasType.settings) values.canvasType = editor.lastCanvasType;
+	yield changeLockSettingsAction({
+		lockSettingType,
+		value,
+		values
+	});
+};
+var RESTORED_SETTERS = {
+	language: changeLanguageAction,
+	tableNameCase: changeTableNameCaseAction,
+	columnNameCase: changeColumnNameCaseAction,
+	bracketType: changeBracketTypeAction,
+	database: changeDatabaseAction
+};
+var RESTORED_UNITS = [...Object.keys(RESTORED_SETTERS), "show"];
+var restoreScreenSettingsAction$ = () => function* ({ editor: { screenBaseline }, settings }) {
+	const units = RESTORED_UNITS.filter((unit) => !isNil(screenBaseline?.[unit]));
+	if (!screenBaseline || !units.length) return;
+	const restores = [];
+	Object.entries(RESTORED_SETTERS).forEach(([unit, setter]) => {
+		const value = screenBaseline[unit];
+		if (!isNil(value) && value !== settings[unit]) restores.push(setter({ value }));
+	});
+	const { show } = screenBaseline;
+	if (!isNil(show)) {
+		const set = show & ~settings.show;
+		const clear = settings.show & ~show;
+		if (set) restores.push(changeShowAction({
+			show: set,
+			value: true
+		}));
+		if (clear) restores.push(changeShowAction({
+			show: clear,
+			value: false
+		}));
+	}
+	yield [...attachActionsTag(Tag.screen, restores), endScreenSettingsAction({ units })];
+};
+var actions$ = {
+	changeZoomLevelAction$,
+	streamZoomLevelAction$,
+	changeLockSettingsAction$
+};
+//#endregion
+export { actions$, changeLockSettingsAction$, changeZoomLevelAction$, pinchZoomAction$, restoreScreenSettingsAction$, streamZoomLevelAction$ };

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

@@ -0,0 +1,65 @@
+import { ActionType } from "./actions.js";
+import { changeDDLScriptAction, changeShowAction, changeZoomLevelAction, scrollToAction, streamScrollToAction, streamZoomLevelAction } from "./atom.actions.js";
+//#region src/engine/modules/settings/history.ts
+var MOVE_MIN = 20;
+var scrollTo = (undoActions, _, { settings }) => {
+	undoActions.push(scrollToAction({
+		originX: settings.originX,
+		originY: settings.originY
+	}));
+};
+var changeShow = (undoActions, { payload: { show, value } }) => {
+	undoActions.push(changeShowAction({
+		show,
+		value: !value
+	}));
+};
+var changeZoomLevel = (undoActions, _, { settings }) => {
+	undoActions.push(changeZoomLevelAction({ value: settings.zoomLevel }));
+};
+var changeDDLScript = (undoActions, { payload: { position } }, { settings }) => {
+	undoActions.push(changeDDLScriptAction({
+		position,
+		value: settings.ddlScripts[position]
+	}));
+};
+var settingsPushUndoHistoryMap = {
+	[ActionType.scrollTo]: scrollTo,
+	[ActionType.changeShow]: changeShow,
+	[ActionType.changeZoomLevel]: changeZoomLevel,
+	[ActionType.changeDDLScript]: changeDDLScript
+};
+var streamScrollTo = (undoActions, redoActions, actions) => {
+	const streamScrollToActions = actions.filter((action) => action.type === streamScrollToAction.type);
+	if (!streamScrollToActions.length) return;
+	const { x, y } = streamScrollToActions.reduce((acc, { payload: { movementX, movementY } }) => {
+		acc.x += movementX;
+		acc.y += movementY;
+		return acc;
+	}, {
+		x: 0,
+		y: 0
+	});
+	if (Math.abs(x) + Math.abs(y) < MOVE_MIN) return;
+	undoActions.push(streamScrollToAction({
+		movementX: -1 * x,
+		movementY: -1 * y
+	}));
+	redoActions.push(streamScrollToAction({
+		movementX: x,
+		movementY: y
+	}));
+};
+var streamZoomLevel = (undoActions, redoActions, actions) => {
+	const streamZoomLevelActions = actions.filter((action) => action.type === streamZoomLevelAction.type);
+	if (!streamZoomLevelActions.length) return;
+	const acc = streamZoomLevelActions.reduce((acc, { payload: { value } }) => acc + value, 0);
+	undoActions.push(streamZoomLevelAction({ value: -1 * acc }));
+	redoActions.push(streamZoomLevelAction({ value: acc }));
+};
+var settingsPushStreamHistoryMap = {
+	[ActionType.streamScrollTo]: streamScrollTo,
+	[ActionType.streamZoomLevel]: streamZoomLevel
+};
+//#endregion
+export { settingsPushStreamHistoryMap, settingsPushUndoHistoryMap };

package/dist/engine/modules/settings/screenBaseline.d.ts

@@ -0,0 +1,37 @@
+import { Editor, ScreenUnit, ScreenViewport } from '../editor/state';
+import { RootState } from '../../state';
+type Settings = RootState['settings'];
+/** A unit that holds one setting alone, every unit but the viewport. */
+export type ScreenSettingUnit = Exclude<ScreenUnit, 'viewport'>;
+/** What a write of a one-setting unit lands in: the screen or the baseline. */
+type SettingTarget = Partial<Pick<Settings, ScreenSettingUnit>>;
+/** Whether a write is a readonly reader's turn of its own screen. */
+export declare const isScreenWrite: (tags?: number) => boolean;
+/** Whether a write is a peer's, or a follow of one. */
+export declare const isRemoteWrite: (tags?: number) => boolean;
+/**
+ * Keeps the document's value of a unit aside before a screen turn writes
+ * over it, once: a later turn of the same unit keeps the first value.
+ */
+export declare function keepScreenBaseline(state: RootState, unit: ScreenUnit): void;
+/** Drops the units named from the baseline, so the screen stands for the document again. */
+export declare function endScreenBaseline(editor: Editor, ...units: ScreenUnit[]): void;
+/**
+ * Where a write of a one-setting unit lands: a screen turn keeps the baseline
+ * and writes the screen, a peer's write lands in a baseline held, and the
+ * reader's own write drops the baseline and writes the screen.
+ */
+export declare function settingWriteTarget(state: RootState, tags: number | undefined, unit: ScreenSettingUnit): SettingTarget;
+/**
+ * Where a scroll or a zoom lands, by the same rule, the three placement
+ * fields one unit: any of the four writes keeps or drops the whole viewport.
+ */
+export declare function viewportWriteTarget(state: RootState, tags: number | undefined): ScreenViewport;
+/**
+ * Lands a replacing load on the baseline, the screen as it stood before. Any
+ * load ends the viewport and an unlocked name view and keeps a locked unit, as
+ * a replica keeps its value; a peer's holds the rest, the reader's own ends it.
+ */
+export declare function landScreenBaseline(state: RootState, screen: SettingTarget, tags: number | undefined): void;
+export {};
+//# sourceMappingURL=screenBaseline.d.ts.map

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

@@ -0,0 +1,82 @@
+import { isSettingLocked } from "../../../erd-editor-schema/dist/v3/schema/settings.js";
+import { LockSettingType } from "../../../constants/schema.js";
+import { bHas } from "../../../utils/bit.js";
+import { Tag } from "../../tag.js";
+import { isNil, pick } from "es-toolkit";
+//#region src/engine/modules/settings/screenBaseline.ts
+var VIEWPORT_FIELDS = [
+	"originX",
+	"originY",
+	"zoomLevel"
+];
+var isScreenWrite = (tags) => !isNil(tags) && bHas(tags, Tag.screen);
+var isRemoteWrite = (tags) => !isNil(tags) && (bHas(tags, Tag.shared) || bHas(tags, Tag.following));
+var hasScreenBaseline = (editor, unit) => !isNil(editor.screenBaseline?.[unit]);
+function keepScreenBaseline(state, unit) {
+	const { editor, settings } = state;
+	if (hasScreenBaseline(editor, unit)) return;
+	if (!editor.screenBaseline) editor.screenBaseline = {};
+	const baseline = editor.screenBaseline;
+	if (unit === "viewport") baseline.viewport = pick(settings, VIEWPORT_FIELDS);
+	else holdSetting(baseline, settings, unit);
+}
+function endScreenBaseline(editor, ...units) {
+	const baseline = editor.screenBaseline;
+	if (!baseline) return;
+	units.forEach((unit) => Reflect.deleteProperty(baseline, unit));
+	if (Object.keys(baseline).length === 0) editor.screenBaseline = null;
+}
+function holdSetting(target, source, unit) {
+	target[unit] = source[unit];
+}
+function settingWriteTarget(state, tags, unit) {
+	const { editor, settings } = state;
+	if (isScreenWrite(tags)) keepScreenBaseline(state, unit);
+	else if (!isRemoteWrite(tags)) endScreenBaseline(editor, unit);
+	else if (editor.screenBaseline && hasScreenBaseline(editor, unit)) return editor.screenBaseline;
+	return settings;
+}
+function viewportWriteTarget(state, tags) {
+	const { editor, settings } = state;
+	if (isScreenWrite(tags)) keepScreenBaseline(state, "viewport");
+	else if (!isRemoteWrite(tags)) endScreenBaseline(editor, "viewport");
+	return isRemoteWrite(tags) && editor.screenBaseline?.viewport || settings;
+}
+var UNIT_LOCKS = {
+	canvasType: LockSettingType.canvasType,
+	nameViewMode: LockSettingType.unlockNameViewMode,
+	language: LockSettingType.language,
+	tableNameCase: LockSettingType.tableNameCase,
+	columnNameCase: LockSettingType.columnNameCase,
+	bracketType: LockSettingType.bracketType
+};
+var LOAD_HELD_UNITS = [
+	"canvasType",
+	"show",
+	"database",
+	"language",
+	"tableNameCase",
+	"columnNameCase",
+	"bracketType"
+];
+var isUnitLocked = (settings, unit) => {
+	const lock = UNIT_LOCKS[unit];
+	return !isNil(lock) && isSettingLocked(settings.lockSettings, lock);
+};
+function landScreenBaseline(state, screen, tags) {
+	const { editor, settings } = state;
+	const baseline = editor.screenBaseline;
+	if (!baseline) return;
+	const ended = ["viewport"];
+	if (!isUnitLocked(settings, "nameViewMode")) ended.push("nameViewMode");
+	LOAD_HELD_UNITS.forEach((unit) => {
+		if (!hasScreenBaseline(editor, unit) || isUnitLocked(settings, unit)) return;
+		if (isRemoteWrite(tags)) {
+			holdSetting(baseline, settings, unit);
+			holdSetting(settings, screen, unit);
+		} else ended.push(unit);
+	});
+	endScreenBaseline(editor, ...ended);
+}
+//#endregion
+export { endScreenBaseline, isRemoteWrite, isScreenWrite, keepScreenBaseline, landScreenBaseline, settingWriteTarget, viewportWriteTarget };

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

@@ -0,0 +1,18 @@
+//#region src/engine/modules/settings/scrollRange.ts
+var unsigned = (value) => value + 0;
+function contentScrollRange(near, far, viewportLength, zoomLevel) {
+	const farEdgeAtStart = -far * zoomLevel;
+	const nearEdgeAtEnd = viewportLength - near * zoomLevel;
+	return {
+		min: unsigned(Math.min(farEdgeAtStart, nearEdgeAtEnd)),
+		max: unsigned(Math.max(farEdgeAtStart, nearEdgeAtEnd))
+	};
+}
+function openingOrigin(origin, near, far, viewportLength, zoomLevel) {
+	const { min, max } = contentScrollRange(near, far, viewportLength, zoomLevel);
+	if (min < origin && origin < max) return origin;
+	const drawn = Math.min(viewportLength, (far - near) * zoomLevel);
+	return unsigned(Math.min(Math.max(origin, min + drawn), max - drawn));
+}
+//#endregion
+export { contentScrollRange, openingOrigin };