@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/engine/rx-operators/readonlyScreenTag.js

@@ -0,0 +1,49 @@
+import { arrayHas } from "../../utils/arrayHas.js";
+import { Tag, attachActionTag, attachActionsTag } from "../tag.js";
+import { isRemoteWrite, isScreenWrite } from "../modules/settings/screenBaseline.js";
+import { changeZoomLevelAction, scrollToAction, streamScrollToAction, streamZoomLevelAction } from "../modules/settings/atom.actions.js";
+import { ScreenSettingActionTypes } from "../actions.js";
+import { Observable } from "rxjs";
+//#region src/engine/rx-operators/readonlyScreenTag.ts
+var hasScreenSetting = arrayHas(ScreenSettingActionTypes);
+var hasViewportWrite = arrayHas([
+	scrollToAction.type,
+	streamScrollToAction.type,
+	changeZoomLevelAction.type,
+	streamZoomLevelAction.type
+]);
+var isLocal = ({ tags }) => !isRemoteWrite(tags) && !isScreenWrite(tags);
+var tagScreen = (action) => hasScreenSetting(action.type) && !isRemoteWrite(action.tags) ? attachActionTag(Tag.screen, action) : action;
+function alignViewport(actions, state) {
+	if (!state.editor.screenBaseline?.viewport) return actions;
+	const index = actions.findIndex((action) => hasViewportWrite(action.type) && isLocal(action));
+	if (index === -1) return actions;
+	const { originX, originY, zoomLevel } = state.settings;
+	const { version } = actions[index];
+	const aligned = attachActionsTag(Tag.changeOnly, [{
+		...scrollToAction({
+			originX,
+			originY
+		}),
+		version
+	}, {
+		...changeZoomLevelAction({ value: zoomLevel }),
+		version
+	}]);
+	return [
+		...actions.slice(0, index),
+		...aligned,
+		...actions.slice(index)
+	];
+}
+var readonlyScreenTag = (getReadonly, getState) => {
+	return (source$) => new Observable((subscriber) => source$.subscribe({
+		next: (actions) => {
+			subscriber.next(getReadonly() ? actions.map(tagScreen) : alignViewport(actions, getState()));
+		},
+		error: (err) => subscriber.error(err),
+		complete: () => subscriber.complete()
+	}));
+};
+//#endregion
+export { alignViewport, readonlyScreenTag };

package/dist/engine/rx-operators/viewActionRedirect.js

@@ -0,0 +1,32 @@
+import { ActionType } from "../modules/editor/actions.js";
+import { bHas } from "../../utils/bit.js";
+import { Tag } from "../tag.js";
+import { ActionType as ActionType$1 } from "../modules/settings/actions.js";
+import { isNil } from "es-toolkit";
+import { Observable } from "rxjs";
+//#region src/engine/rx-operators/viewActionRedirect.ts
+var REDIRECT = {
+	[ActionType$1.scrollTo]: ActionType.viewScrollTo,
+	[ActionType$1.streamScrollTo]: ActionType.viewStreamScrollTo,
+	[ActionType$1.changeZoomLevel]: ActionType.viewChangeZoomLevel,
+	[ActionType$1.streamZoomLevel]: ActionType.viewStreamZoomLevel
+};
+var isRemote = ({ tags }) => !isNil(tags) && (bHas(tags, Tag.shared) || bHas(tags, Tag.following));
+var redirect = (action) => {
+	const type = REDIRECT[action.type];
+	return type && !isRemote(action) ? {
+		...action,
+		type
+	} : action;
+};
+var viewActionRedirect = (getActiveView) => {
+	return (source$) => new Observable((subscriber) => source$.subscribe({
+		next: (actions) => {
+			subscriber.next(getActiveView() ? actions.map(redirect) : actions);
+		},
+		error: (err) => subscriber.error(err),
+		complete: () => subscriber.complete()
+	}));
+};
+//#endregion
+export { viewActionRedirect };

package/dist/engine/rx-operators/viewIgnoreFilter.js

@@ -0,0 +1,22 @@
+import { arrayHas } from "../../utils/arrayHas.js";
+import { bHas } from "../../utils/bit.js";
+import { ViewIgnoreActionTypes } from "../actions.js";
+import { notEmptyActions } from "./notEmptyActions.js";
+import { isNil } from "es-toolkit";
+import { Observable } from "rxjs";
+//#region src/engine/rx-operators/viewIgnoreFilter.ts
+var viewIgnoreFilter = (getActiveView, passTags = []) => {
+	const has = arrayHas(ViewIgnoreActionTypes);
+	const predicate = (action) => {
+		return !isNil(action.tags) && passTags.some((tag) => bHas(action.tags, tag)) || !has(action.type);
+	};
+	return (source$) => new Observable((subscriber) => source$.subscribe({
+		next: (actions) => {
+			subscriber.next(getActiveView() ? actions.filter(predicate) : actions);
+		},
+		error: (err) => subscriber.error(err),
+		complete: () => subscriber.complete()
+	})).pipe(notEmptyActions);
+};
+//#endregion
+export { viewIgnoreFilter };

package/dist/engine/rx-store.d.ts

@@ -22,9 +22,20 @@ export type RxStore = Store & {
     flushStreamBuffers: () => void;
     /** Whether the editor is readonly now, which drops every edit of the document. */
     getReadonly: () => boolean;
+    /**
+     * Whether it was created with readonlyEditState, which a shared store over
+     * it reads to send none of its changes while it is readonly.
+     */
+    readonlyEditState: boolean;
 };
 export type RxStoreOptions = {
     getReadonly?: () => boolean;
+    /**
+     * While readonly, also drops what opens an edit, sends a peer no change and
+     * keeps each setting its reader turns on its own screen. Only the editor
+     * element's store sets it; the viewer's and the diff panes' do not.
+     */
+    readonlyEditState?: boolean;
     getHistory?: (options: HistoryOptions) => History;
     /** Closes stream buffers on flushStreamBuffers() instead of after 200 ms. */
     manualStreamFlush?: boolean;
@@ -35,5 +46,5 @@ export type RxStoreOptions = {
     observable?: boolean;
 };
 export declare const HISTORY_LIMIT = 2048;
-export declare function createRxStore(context: EngineContext, { getReadonly, getHistory, manualStreamFlush, observable, }?: RxStoreOptions): RxStore;
+export declare function createRxStore(context: EngineContext, { getReadonly, readonlyEditState, getHistory, manualStreamFlush, observable, }?: RxStoreOptions): RxStore;
 //# sourceMappingURL=rx-store.d.ts.map

package/dist/engine/rx-store.js

@@ -0,0 +1,158 @@
+import { arrayHas } from "../utils/arrayHas.js";
+import { compositionActionsFlat } from "../r-html/dist/store/index.js";
+import { DictionaryKindList } from "./modules/dictionary/actions.js";
+import { ActionType } from "./modules/editor/actions.js";
+import { getActiveView } from "./modules/editor/view.js";
+import { Tag, hasActionTag } from "./tag.js";
+import { changeHasHistoryAction, keepsDictionaries } from "./modules/editor/atom.actions.js";
+import { isDictionaryAction, pushHistory, pushSheetHistory } from "./history.actions.js";
+import { ChangeActionTypes, EditStateOpenActionTypes, HistoryActionTypes, StreamActionTypes, StreamRegroupColorActionTypes, StreamRegroupMoveActionTypes, StreamRegroupScrollActionTypes, opensEditDialog } from "./actions.js";
+import { createHistory } from "./history.js";
+import { actionsFilter } from "./rx-operators/actionsFilter.js";
+import { groupByStreamActions } from "./rx-operators/groupByStreamActions.js";
+import { ignoreTagFilter } from "./rx-operators/ignoreTagFilter.js";
+import { flushOnNotifier } from "./rx-operators/flushOnNotifier.js";
+import { lockIgnoreFilter } from "./rx-operators/lockIgnoreFilter.js";
+import { readonlyIgnoreFilter } from "./rx-operators/readonlyIgnoreFilter.js";
+import { alignViewport, readonlyScreenTag } from "./rx-operators/readonlyScreenTag.js";
+import { viewActionRedirect } from "./rx-operators/viewActionRedirect.js";
+import { viewIgnoreFilter } from "./rx-operators/viewIgnoreFilter.js";
+import { createStore } from "./store.js";
+import { createHooks } from "./store-hooks.js";
+import { isFunction, isNil } from "es-toolkit";
+import { Observable, Subject, debounceTime, filter, startWith, switchMap } from "rxjs";
+//#region src/engine/rx-store.ts
+var HISTORY_LIMIT = 2048;
+var isLoadOrClear = arrayHas([ActionType.loadJson, ActionType.clear]);
+var isDocumentReplace = ({ type, payload }) => isLoadOrClear(type) && !keepsDictionaries(payload);
+function createRxStore(context, { getReadonly = () => false, readonlyEditState = false, getHistory, manualStreamFlush = false, observable = true } = {}) {
+	const subscriptionSet = /* @__PURE__ */ new Set();
+	const store = createStore(context, observable);
+	const hooks = createHooks(store);
+	const historyOptions = {
+		notify: (payload) => store.dispatch(changeHasHistoryAction(payload)),
+		dispatch: readonlyEditState ? (actions) => store.dispatchSync(alignViewport(actions, store.state)) : store.dispatchSync,
+		getNextVersion: () => context.clock.getNextVersion(),
+		getState: () => store.state
+	};
+	const history = getHistory?.(historyOptions) ?? createHistory(historyOptions);
+	history.setLimit(HISTORY_LIMIT);
+	const sheetHistories = Object.fromEntries(DictionaryKindList.map((sheet) => {
+		const sheetHistory = createHistory({
+			...historyOptions,
+			notify: (payload) => store.dispatch(changeHasHistoryAction({
+				...payload,
+				sheet
+			}))
+		});
+		sheetHistory.setLimit(HISTORY_LIMIT);
+		return [sheet, sheetHistory];
+	}));
+	const clearSheetHistories = () => DictionaryKindList.forEach((sheet) => sheetHistories[sheet].clear());
+	const sheetHistoryOf = (actions) => {
+		const row = actions.find(isDictionaryAction);
+		return row ? sheetHistories[row.payload?.kind] : null;
+	};
+	const toHistory = (actions) => {
+		const sheetHistory = hasActionTag(actions, Tag.dictionarySheet) ? sheetHistoryOf(actions) : null;
+		if (sheetHistory) pushSheetHistory(store, sheetHistory)(actions);
+		else historyInput$.next(actions);
+	};
+	const getView = () => getActiveView(store.state);
+	const dispatch$ = new Subject();
+	const viewRedirected$ = dispatch$.pipe(viewActionRedirect(getView));
+	const redirected$ = readonlyEditState ? viewRedirected$.pipe(readonlyScreenTag(getReadonly, () => store.state)) : viewRedirected$;
+	const historyInput$ = new Subject();
+	const historyReset$ = new Subject();
+	const flush$ = new Subject();
+	const history$ = historyReset$.pipe(startWith(void 0), switchMap(() => historyInput$.pipe(groupByStreamActions(StreamActionTypes, [
+		[
+			"@@move",
+			StreamRegroupMoveActionTypes,
+			Tag.drag
+		],
+		["@@scroll", StreamRegroupScrollActionTypes],
+		["@@color", StreamRegroupColorActionTypes]
+	], manualStreamFlush ? flushOnNotifier(flush$) : void 0))));
+	const change$ = new Observable((subscriber) => store.subscribe((actions) => subscriber.next(actions))).pipe(actionsFilter(ChangeActionTypes), ignoreTagFilter([Tag.screen]), lockIgnoreFilter(() => store.state.settings.lockSettings), readonlyIgnoreFilter(getReadonly, [Tag.shared], ChangeActionTypes), debounceTime(200));
+	const toActions = (...compositionActions) => {
+		const version = context.clock.getNextVersion();
+		return compositionActionsFlat(store.state, store.context, compositionActions).map((action) => {
+			if (isNil(action.version)) action.version = version;
+			return action;
+		});
+	};
+	const dispatchSync = (...compositionActions) => {
+		const actions = toActions(compositionActions);
+		dispatch$.next(actions);
+	};
+	const dispatch = (...compositionActions) => {
+		queueMicrotask(() => dispatchSync(compositionActions));
+	};
+	const destroy = () => {
+		Array.from(subscriptionSet).forEach((sub) => isFunction(sub) ? sub() : sub.unsubscribe());
+		subscriptionSet.clear();
+		store.destroy();
+		hooks.destroy();
+		history.clear();
+		clearSheetHistories();
+		dispatch$.complete();
+		flush$.complete();
+	};
+	const resetHistory = () => {
+		historyReset$.next();
+		history.clear();
+		clearSheetHistories();
+	};
+	const undo = () => {
+		if (getReadonly() || getView()) return;
+		history.undo();
+	};
+	const redo = () => {
+		if (getReadonly() || getView()) return;
+		history.redo();
+	};
+	const undoSheet = (sheet) => {
+		if (getReadonly() || getView()) return;
+		sheetHistories[sheet]?.undo();
+	};
+	const redoSheet = (sheet) => {
+		if (getReadonly() || getView()) return;
+		sheetHistories[sheet]?.redo();
+	};
+	const flushStreamBuffers = () => {
+		if (manualStreamFlush) flush$.next();
+	};
+	const mergeClock = () => {
+		return store.subscribe((actions) => {
+			actions.forEach((action) => context.clock.merge(action.version));
+		});
+	};
+	const clearSheetsOnReplace = () => store.subscribe((actions) => {
+		if (actions.some(isDocumentReplace)) clearSheetHistories();
+	});
+	subscriptionSet.add(history$.subscribe(pushHistory(store, history))).add(redirected$.pipe(actionsFilter(HistoryActionTypes), ignoreTagFilter([
+		Tag.changeOnly,
+		Tag.shared,
+		Tag.screen
+	]), filter(() => !getReadonly()), viewIgnoreFilter(getView)).subscribe(toHistory)).add(redirected$.pipe(readonlyIgnoreFilter(getReadonly, [Tag.shared, Tag.screen], readonlyEditState ? EditStateOpenActionTypes : [], readonlyEditState ? opensEditDialog : void 0), viewIgnoreFilter(getView, [Tag.shared, Tag.screen])).subscribe(store.dispatchSync)).add(mergeClock()).add(clearSheetsOnReplace());
+	return Object.freeze({
+		...store,
+		dispatch,
+		dispatchSync,
+		destroy,
+		undo,
+		redo,
+		history,
+		sheetHistories,
+		undoSheet,
+		redoSheet,
+		resetHistory,
+		change$,
+		flushStreamBuffers,
+		getReadonly,
+		readonlyEditState
+	});
+}
+//#endregion
+export { HISTORY_LIMIT, createRxStore };

package/dist/engine/settle.js

@@ -0,0 +1,15 @@
+import { recalculateTableWidth } from "../utils/calcTable.js";
+import { recalculateIdentification, recalculateStartRelationshipType } from "./modules/relationship/endFlags.js";
+import { syncPrimaryKeys, validateForeignKeys } from "./modules/table-column/keys.js";
+import { relationshipSort } from "../utils/draw-relationship/sort.js";
+//#region src/engine/settle.ts
+function settleDocument(state, ctx) {
+	syncPrimaryKeys(state);
+	validateForeignKeys(state);
+	recalculateTableWidth(state, ctx);
+	relationshipSort(state, "document", { route: ctx.routes !== false });
+	recalculateIdentification(state);
+	recalculateStartRelationshipType(state);
+}
+//#endregion
+export { settleDocument };

package/dist/engine/shared-store.js

@@ -0,0 +1,114 @@
+import { arrayHas } from "../utils/arrayHas.js";
+import { Tag, attachActionTag, attachActionsTag } from "./tag.js";
+import { getLWWAction, initialLoadJsonAction, mergeLWWAction } from "./modules/editor/atom.actions.js";
+import { ChangeActionTypes, SharedActionTypes, SharedFollowingActionTypes } from "./actions.js";
+import { actionsFilter } from "./rx-operators/actionsFilter.js";
+import { bufferCircuitBreaker } from "./rx-operators/bufferCircuitBreaker.js";
+import { ignoreTagFilter } from "./rx-operators/ignoreTagFilter.js";
+import { createSharedStreamActionsCompressor } from "./rx-operators/createSharedStreamActionsCompressor.js";
+import { flushOnNotifier, quietPeriodOrNotifier } from "./rx-operators/flushOnNotifier.js";
+import { readonlyIgnoreFilter } from "./rx-operators/readonlyIgnoreFilter.js";
+import { isEmpty } from "es-toolkit/compat";
+import { Observable, Subject, filter, map, merge } from "rxjs";
+//#region src/engine/shared-store.ts
+var FLUSH_TICKS = 2;
+var hasSharedFollowingActionTypes = arrayHas(SharedFollowingActionTypes);
+function createSharedStore(store, config, internal) {
+	const manualStreamFlush = internal?.manualStreamFlush ?? false;
+	const sharedMeta = { editorId: store.state.editor.id };
+	const subscriptionSet = /* @__PURE__ */ new Set();
+	const observerSubscriptionSet = /* @__PURE__ */ new Set();
+	const observer$ = new Subject();
+	const internal$ = new Subject();
+	const openingNotifier$ = new Subject();
+	const closingNotifier$ = new Subject();
+	const flush$ = new Subject();
+	const compressor = createSharedStreamActionsCompressor(manualStreamFlush ? flushOnNotifier(flush$) : quietPeriodOrNotifier(flush$));
+	const getReadonly = store.readonlyEditState ? store.getReadonly : () => false;
+	let isConnection = true;
+	let firstSubscribe = true;
+	subscriptionSet.add(merge(new Observable((subscriber) => store.subscribe((actions) => subscriber.next(actions))), internal$).pipe(actionsFilter(SharedActionTypes), ignoreTagFilter([Tag.shared, Tag.screen]), readonlyIgnoreFilter(getReadonly, [], ChangeActionTypes), compressor, bufferCircuitBreaker(openingNotifier$, closingNotifier$), compressor, map((actions) => attachActionsTag(Tag.shared, actions.map((action) => {
+		const newAction = {
+			...action,
+			meta: Object.assign({}, action.meta ?? {}, {
+				...sharedMeta,
+				nickname: config?.getNickname?.()
+			})
+		};
+		return hasSharedFollowingActionTypes(action.type) ? attachActionTag(Tag.following, newAction) : newAction;
+	})))).subscribe((actions) => observer$.next(actions)));
+	const requestLWW = () => {
+		internal$.next([{
+			...getLWWAction(),
+			version: store.context.clock.getVersion()
+		}]);
+	};
+	subscriptionSet.add(new Observable((subscriber) => store.subscribe((actions) => subscriber.next(actions))).pipe(filter((actions) => !firstSubscribe && actions.some(({ type }) => type === initialLoadJsonAction.type))).subscribe(requestLWW));
+	const halfOpenNotify = () => {
+		const isSubscribe = 0 < observerSubscriptionSet.size;
+		if (isConnection && isSubscribe) openingNotifier$.next();
+		else closingNotifier$.next();
+	};
+	const toMergeLWWAction = (actions) => {
+		const isGetLWWAction = (Array.isArray(actions) ? actions : [actions]).some((action) => action.type === getLWWAction.type);
+		const lww = store.state.lww;
+		if (isGetLWWAction && !isEmpty(lww)) internal$.next([{
+			...mergeLWWAction({ lww }),
+			version: store.context.clock.getVersion()
+		}]);
+	};
+	const subscribe = (fn) => {
+		const subscription = observer$.subscribe((actions) => fn(actions));
+		observerSubscriptionSet.add(subscription);
+		halfOpenNotify();
+		if (firstSubscribe) {
+			requestLWW();
+			firstSubscribe = false;
+		}
+		return () => {
+			subscription.unsubscribe();
+			observerSubscriptionSet.delete(subscription);
+			halfOpenNotify();
+		};
+	};
+	const connection = () => {
+		isConnection = true;
+		halfOpenNotify();
+	};
+	const disconnect = () => {
+		isConnection = false;
+		halfOpenNotify();
+	};
+	const dispatchSync = (actions) => {
+		store.dispatchSync(actions);
+		toMergeLWWAction(actions);
+	};
+	const dispatch = (actions) => {
+		store.dispatch(actions);
+		toMergeLWWAction(actions);
+	};
+	const flushStreamBuffers = () => {
+		for (let tick = 0; tick < FLUSH_TICKS; tick++) flush$.next();
+	};
+	const destroy = () => {
+		Array.from(subscriptionSet).forEach((sub) => sub.unsubscribe());
+		Array.from(observerSubscriptionSet).forEach((sub) => sub.unsubscribe());
+		subscriptionSet.clear();
+		observerSubscriptionSet.clear();
+		observer$.complete();
+		openingNotifier$.complete();
+		closingNotifier$.complete();
+		flush$.complete();
+	};
+	return Object.freeze({
+		connection,
+		disconnect,
+		dispatch,
+		dispatchSync,
+		subscribe,
+		flushStreamBuffers,
+		destroy
+	});
+}
+//#endregion
+export { createSharedStore };

package/dist/engine/store-hooks.js

@@ -0,0 +1,36 @@
+import { arrayHas } from "../utils/arrayHas.js";
+import { hooks as hooks$1 } from "./modules/relationship/hooks.js";
+import { hooks as hooks$2 } from "./modules/table/hooks.js";
+import { hooks as hooks$3 } from "./modules/table-column/hooks.js";
+import { Subject } from "rxjs";
+//#region src/engine/store-hooks.ts
+var hooks = [
+	...hooks$2,
+	...hooks$3,
+	...hooks$1
+];
+function createHooks(store) {
+	const getState = () => store.state;
+	const tasks = hooks.map(([pattern, hook]) => {
+		const action$ = new Subject();
+		return {
+			pattern: arrayHas(pattern.map(String)),
+			action$,
+			subscription: hook(action$, getState, store.context)
+		};
+	});
+	const unsubscribe = store.subscribe((actions) => {
+		for (const action of actions) for (const task of tasks) if (task.pattern(action.type)) task.action$.next(action);
+	});
+	const destroy = () => {
+		tasks.forEach(({ action$, subscription }) => {
+			subscription.unsubscribe();
+			action$.complete();
+		});
+		tasks.splice(0, tasks.length);
+		unsubscribe();
+	};
+	return { destroy };
+}
+//#endregion
+export { createHooks };

package/dist/engine/store.js

@@ -0,0 +1,39 @@
+import { createSchema } from "../erd-editor-schema/dist/v3/parser/index.js";
+import { createStore as createStore$1 } from "../r-html/dist/store/index.js";
+import { tableColumnReducers } from "./modules/table-column/atom.actions.js";
+import { dictionaryReducers } from "./modules/dictionary/atom.actions.js";
+import { createEditor } from "./modules/editor/state.js";
+import { settingsReducers } from "./modules/settings/atom.actions.js";
+import { editorReducers } from "./modules/editor/atom.actions.js";
+import { indexReducers } from "./modules/index/atom.actions.js";
+import { indexColumnReducers } from "./modules/index-column/atom.actions.js";
+import { memoReducers } from "./modules/memo/atom.actions.js";
+import { relationshipReducers } from "./modules/relationship/atom.actions.js";
+import { tableReducers } from "./modules/table/atom.actions.js";
+import { tableGroupReducers } from "./modules/table-group/atom.actions.js";
+//#region src/engine/store.ts
+function createStore(context, enableObservable) {
+	return createStore$1({
+		context,
+		state: {
+			...createSchema(),
+			editor: createEditor(),
+			lww: {}
+		},
+		reducers: {
+			...editorReducers,
+			...tableReducers,
+			...tableColumnReducers,
+			...memoReducers,
+			...relationshipReducers,
+			...settingsReducers,
+			...indexReducers,
+			...indexColumnReducers,
+			...tableGroupReducers,
+			...dictionaryReducers
+		},
+		enableObservable: enableObservable ?? true
+	});
+}
+//#endregion
+export { createStore };

package/dist/engine/stream-flush.js

@@ -0,0 +1,9 @@
+//#region src/engine/stream-flush.ts
+function createStreamFlusher(rxStore, sharedStore) {
+	return Object.freeze({ flush: () => {
+		rxStore.flushStreamBuffers();
+		sharedStore.flushStreamBuffers();
+	} });
+}
+//#endregion
+export { createStreamFlusher };

package/dist/engine/tag.d.ts

@@ -11,6 +11,11 @@ export declare const Tag: {
      * sheet its dictionary rows are on rather than the document's.
      */
     readonly dictionarySheet: 16;
+    /**
+     * A setting a readonly reader turns on its own screen alone: it never reaches
+     * the file, the history, the change event or a peer.
+     */
+    readonly screen: 32;
 };
 export declare function attachActionTag(tag: number, action: AnyAction): AnyAction;
 export declare function attachActionsTag(tag: number, actions: AnyAction[]): AnyAction[];

package/dist/engine/tag.js

@@ -0,0 +1,28 @@
+import { compositionActionsFlat } from "../r-html/dist/store/index.js";
+import { cloneDeep, isNumber } from "es-toolkit";
+//#region src/engine/tag.ts
+var Tag = {
+	shared: 1,
+	changeOnly: 2,
+	following: 4,
+	drag: 8,
+	dictionarySheet: 16,
+	screen: 32
+};
+function attachActionTag(tag, action) {
+	return {
+		...cloneDeep(action),
+		tags: isNumber(action.tags) && Number.isInteger(action.tags) ? action.tags | tag : tag
+	};
+}
+function attachActionsTag(tag, actions) {
+	return actions.map((action) => attachActionTag(tag, action));
+}
+var createAttachActionsTag = (tag) => (...compositionActions) => function* (state, ctx) {
+	yield attachActionsTag(tag, compositionActionsFlat(state, ctx, compositionActions));
+};
+var attachChangeOnlyTag$ = createAttachActionsTag(Tag.changeOnly);
+var attachDictionarySheetTag$ = createAttachActionsTag(Tag.dictionarySheet);
+var hasActionTag = (actions, tag) => actions.some(({ tags }) => isNumber(tags) && Number.isInteger(tags) && (tags & tag) !== 0);
+//#endregion
+export { Tag, attachActionTag, attachActionsTag, attachChangeOnlyTag$, attachDictionarySheetTag$, hasActionTag };

package/dist/engine/to-width.js

@@ -0,0 +1,6 @@
+//#region src/engine/to-width.ts
+var TEXT_PADDING = 2;
+var CHARACTER_WIDTH = 10;
+var defaultToWidth = (text) => Math.round(text.length * CHARACTER_WIDTH) + TEXT_PADDING;
+//#endregion
+export { defaultToWidth };

package/dist/erd-editor-schema/dist/_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/defineProperty.js

@@ -0,0 +1,12 @@
+import toPropertyKey from "./toPropertyKey.js";
+//#region ../erd-editor-schema/dist/_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+export { _defineProperty as default };

package/dist/erd-editor-schema/dist/_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/toPrimitive.js

@@ -0,0 +1,14 @@
+import _typeof from "./typeof.js";
+//#region ../erd-editor-schema/dist/_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+export { toPrimitive as default };

package/dist/erd-editor-schema/dist/_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/toPropertyKey.js

@@ -0,0 +1,9 @@
+import _typeof from "./typeof.js";
+import toPrimitive from "./toPrimitive.js";
+//#region ../erd-editor-schema/dist/_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+export { toPropertyKey as default };

package/dist/erd-editor-schema/dist/_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/typeof.js

@@ -0,0 +1,11 @@
+//#region ../erd-editor-schema/dist/_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+export { _typeof as default };