@dineug/erd-editor 4.1.0 → 5.0.0

package/dist/engine/documentJson.js

@@ -0,0 +1,20 @@
+import { toJson } from "../erd-editor-schema/dist/parser.js";
+import { toDocumentJson } from "../erd-editor-schema/dist/storageForm.js";
+//#region src/engine/documentJson.ts
+function withScreenBaseline(state) {
+	const baseline = state.editor.screenBaseline;
+	if (!baseline) return state;
+	const { viewport, ...settings } = baseline;
+	return {
+		...state,
+		settings: {
+			...state.settings,
+			...viewport,
+			...settings
+		}
+	};
+}
+var documentJsonOf = ({ state }) => toDocumentJson(withScreenBaseline(state));
+var runtimeJsonOf = ({ state }) => toJson(withScreenBaseline(state));
+//#endregion
+export { documentJsonOf, runtimeJsonOf, withScreenBaseline };

package/dist/engine/history.actions.d.ts

@@ -7,4 +7,12 @@ export type PushStreamHistory = (undoActions: AnyAction[], redoActions: AnyActio
 export declare const pushUndoHistoryMap: Record<string, PushUndoHistory>;
 export declare const pushStreamHistoryMap: Record<string, PushStreamHistory>;
 export declare const pushHistory: (store: Store, history: History) => (actions: AnyAction[]) => void;
+/** Whether an action writes a dictionary row, the actions a sheet's history holds. */
+export declare const isDictionaryAction: ({ type }: AnyAction) => boolean;
+/**
+ * Pushes a Dictionary tab batch onto its sheet's history: its row actions and
+ * the links it took off columns, the column writes a domain's type spread to
+ * worked out again at each replay, which keeps the links it takes off in turn.
+ */
+export declare const pushSheetHistory: (store: Store, history: History) => (actions: AnyAction[]) => void;
 //# sourceMappingURL=history.actions.d.ts.map

package/dist/engine/history.actions.js

@@ -0,0 +1,224 @@
+import { query } from "../erd-editor-schema/dist/query/index.js";
+import { DictionaryKind } from "./modules/dictionary/actions.js";
+import { isListed } from "./modules/dictionary/membership.js";
+import { ActionType } from "./modules/table-column/actions.js";
+import { changeColumnDomainAction } from "./modules/table-column/atom.actions.js";
+import { domainTypeIn, toDomainTypeActions, toDomainUnlinkActions } from "./modules/dictionary/domainTypes.js";
+import { dictionaryPushUndoHistoryMap, reverseDictionaryListings } from "./modules/dictionary/history.js";
+import { ActionType as ActionType$1 } from "./modules/editor/actions.js";
+import { keepsDictionaries } from "./modules/editor/atom.actions.js";
+import { editorPushUndoHistoryMap } from "./modules/editor/history.js";
+import { indexPushUndoHistoryMap } from "./modules/index/history.js";
+import { indexColumnPushUndoHistoryMap } from "./modules/index-column/history.js";
+import { memoPushStreamHistoryMap, memoPushUndoHistoryMap } from "./modules/memo/history.js";
+import { relationshipPushUndoHistoryMap } from "./modules/relationship/history.js";
+import { settingsPushStreamHistoryMap, settingsPushUndoHistoryMap } from "./modules/settings/history.js";
+import { ActionType as ActionType$2 } from "./modules/table/actions.js";
+import { tablePushStreamHistoryMap, tablePushUndoHistoryMap } from "./modules/table/history.js";
+import { tableColumnPushUndoHistoryMap } from "./modules/table-column/history.js";
+import { tableGroupPushStreamHistoryMap, tableGroupPushUndoHistoryMap } from "./modules/table-group/history.js";
+import { safeCallback } from "../utils/safeCallback.js";
+import { cloneDeep, isString } from "es-toolkit";
+//#region src/engine/history.actions.ts
+var pushUndoHistoryMap = {
+	...tablePushUndoHistoryMap,
+	...tableColumnPushUndoHistoryMap,
+	...relationshipPushUndoHistoryMap,
+	...memoPushUndoHistoryMap,
+	...settingsPushUndoHistoryMap,
+	...editorPushUndoHistoryMap,
+	...indexPushUndoHistoryMap,
+	...indexColumnPushUndoHistoryMap,
+	...tableGroupPushUndoHistoryMap,
+	...dictionaryPushUndoHistoryMap
+};
+var pushStreamHistoryMap = {
+	...tablePushStreamHistoryMap,
+	...memoPushStreamHistoryMap,
+	...settingsPushStreamHistoryMap,
+	...tableGroupPushStreamHistoryMap
+};
+function push(store, history, actions) {
+	const undoActions = [];
+	const redoActions = [];
+	for (const action of actions) {
+		const pushUndoHistory = pushUndoHistoryMap[action.type];
+		if (!pushUndoHistory) continue;
+		pushUndoHistory(undoActions, action, store.state);
+		redoActions.push(cloneDeep(action));
+	}
+	reverseDictionaryListings(undoActions);
+	for (const key of Object.keys(pushStreamHistoryMap)) pushStreamHistoryMap[key](undoActions, redoActions, actions);
+	if (!undoActions.length || !redoActions.length) return;
+	history.push({
+		undo: replayDocument(store, undoActions),
+		redo: replayDocument(store, redoActions)
+	});
+}
+function cloneAction(version) {
+	return (action) => ({
+		...cloneDeep(action),
+		version
+	});
+}
+var isUnlink = ({ type, payload }) => type === ActionType.changeColumnDomain && payload.value === "";
+var unlinkedIdsOf = (actions) => new Set(actions.filter(isUnlink).map(({ payload }) => payload.id));
+function endTypeOf(state, actions) {
+	const columns = query(state.collections).collection("tableColumnEntities");
+	const written = /* @__PURE__ */ new Map();
+	for (const { type, payload } of actions) if (type === ActionType.changeColumnDataType) written.set(payload.id, payload.value);
+	return (id) => written.get(id) ?? columns.selectById(id)?.dataType ?? "";
+}
+function liveLinks({ doc, collections }) {
+	const columns = query(collections).collection("tableColumnEntities");
+	return query(collections).collection("tableEntities").selectByIds(doc.tableIds).flatMap(({ id: tableId, columnIds }) => columns.selectByIds(columnIds).filter(({ domainId }) => domainId !== "").map(({ id, domainId }) => ({
+		tableId,
+		id,
+		value: domainId
+	})));
+}
+function liveColumnIn({ doc, collections }) {
+	const tables = query(collections).collection("tableEntities");
+	const listed = new Set(doc.tableIds);
+	const held = /* @__PURE__ */ new Map();
+	return (tableId, id) => {
+		if (!listed.has(tableId)) return false;
+		const ids = held.get(tableId) ?? new Set(tables.selectById(tableId)?.columnIds);
+		held.set(tableId, ids);
+		return ids.has(id);
+	};
+}
+function touchedBy(state, actions) {
+	const tables = query(state.collections).collection("tableEntities");
+	const governed = /* @__PURE__ */ new Map();
+	const typed = /* @__PURE__ */ new Map();
+	const links = /* @__PURE__ */ new Map();
+	const domainIds = new Set(domainTypesOf(actions).keys());
+	let loaded = false;
+	for (const { type, payload } of actions) if (type === ActionType.changeColumnDomain) links.set(payload.id, payload);
+	else if (type === ActionType.changeColumnDataType) typed.set(payload.id, payload.tableId);
+	else if (type === ActionType.addColumn) governed.set(payload.id, payload.tableId);
+	else if (type === ActionType$2.addTable) for (const id of tables.selectById(payload.id)?.columnIds ?? []) governed.set(id, payload.id);
+	else if (type === ActionType$1.loadJson) loaded ||= keepsDictionaries(payload);
+	for (const { tableId, id, value } of links.values()) if (value !== "") governed.set(id, tableId);
+	if (loaded || domainIds.size) {
+		for (const { tableId, id, value } of liveLinks(state)) if (loaded || domainIds.has(value)) governed.set(id, tableId);
+	}
+	const isLive = liveColumnIn(state);
+	const live = (ids) => new Map([...ids].filter(([id, tableId]) => isLive(tableId, id)));
+	return {
+		governed: live(governed),
+		typed: live(typed)
+	};
+}
+function settle(state, { governed, typed }) {
+	const columns = query(state.collections).collection("tableColumnEntities");
+	const domainTypeOf = domainTypeIn(state, /* @__PURE__ */ new Map());
+	const drifted = [];
+	const judged = new Map(typed);
+	for (const [id, tableId] of governed) {
+		const column = columns.selectById(id);
+		if (!column?.domainId) continue;
+		if (!isListed(state.doc.domainIds, column.domainId)) judged.set(id, tableId);
+		else if (column.dataType !== domainTypeOf(column.domainId)) drifted.push({
+			tableId,
+			id,
+			value: column.domainId
+		});
+	}
+	const retyped = drifted.length ? toDomainTypeActions(state, { links: drifted }) : [];
+	const typeOf = endTypeOf(state, retyped);
+	const unlinked = unlinkedIdsOf(retyped);
+	const unlinks = toDomainUnlinkActions(state, [...judged].map(([id, tableId]) => ({
+		tableId,
+		id,
+		value: typeOf(id)
+	}))).filter(({ payload }) => !unlinked.has(payload.id));
+	return [...retyped, ...unlinks];
+}
+var replayDocument = (store, actions) => (dispatch, getNextVersion, getState = () => store.state) => {
+	dispatch(actions.map(cloneAction(getNextVersion())));
+	const state = getState();
+	const settled = settle(state, touchedBy(state, actions));
+	if (settled.length) dispatch(settled.map(cloneAction(getNextVersion())));
+};
+var pushHistory = (store, history) => (actions) => {
+	safeCallback(push, store, history, actions);
+};
+var isDictionaryAction = ({ type }) => type.startsWith("dictionary.");
+function domainTypesOf(actions) {
+	const domainTypes = /* @__PURE__ */ new Map();
+	for (const { payload } of actions.filter(isDictionaryAction)) {
+		const dataType = payload?.values?.dataType;
+		if (payload?.kind === DictionaryKind.domain && isString(dataType)) domainTypes.set(payload.id, dataType);
+	}
+	return domainTypes;
+}
+var replayRows = (store, rows, unlinked) => (dispatch, getNextVersion, getState = () => store.state) => {
+	const state = getState();
+	const held = query(state.collections).collection("tableColumnEntities");
+	const restored = unlinked.links.filter(({ link, dataType }) => {
+		const column = held.selectById(link.id);
+		return column?.domainId === "" && column.dataType === dataType;
+	}).map(({ link }) => link);
+	const domainTypes = domainTypesOf(rows);
+	const columns = toDomainTypeActions(state, {
+		domainTypes,
+		links: restored
+	});
+	const typeOf = endTypeOf(state, columns);
+	const domainTypeOf = domainTypeIn(state, domainTypes);
+	const relinks = restored.filter(({ id, value }) => !isListed(state.doc.domainIds, value) && typeOf(id) === domainTypeOf(value)).map(changeColumnDomainAction);
+	const unlinkedIds = unlinkedIdsOf(columns);
+	const offRemoved = toDomainUnlinkActions(state, liveLinks(state).filter(({ id, value }) => domainTypes.has(value) && !isListed(state.doc.domainIds, value) && !unlinkedIds.has(id)).map(({ tableId, id }) => ({
+		tableId,
+		id,
+		value: typeOf(id)
+	})), { domainTypes });
+	const sent = [
+		...columns,
+		...relinks,
+		...offRemoved
+	];
+	unlinked.links = unlinksOf(state, sent);
+	dispatch([...rows, ...sent].map(cloneAction(getNextVersion())));
+};
+function unlinksOf(state, actions) {
+	const columns = query(state.collections).collection("tableColumnEntities");
+	const typeOf = endTypeOf(state, actions);
+	return actions.filter(isUnlink).flatMap(({ payload: { tableId, id } }) => {
+		const value = columns.selectById(id)?.domainId ?? "";
+		if (value === "") return [];
+		return [{
+			link: {
+				tableId,
+				id,
+				value
+			},
+			dataType: typeOf(id)
+		}];
+	});
+}
+function pushSheet(store, history, actions) {
+	const rows = actions.filter(isDictionaryAction);
+	const undoActions = [];
+	const redoActions = [];
+	for (const action of rows) {
+		const pushUndoHistory = pushUndoHistoryMap[action.type];
+		if (!pushUndoHistory) continue;
+		pushUndoHistory(undoActions, action, store.state);
+		redoActions.push(cloneDeep(action));
+	}
+	reverseDictionaryListings(undoActions);
+	if (!undoActions.length || !redoActions.length) return;
+	const unlinked = { links: unlinksOf(store.state, actions) };
+	history.push({
+		undo: replayRows(store, undoActions, unlinked),
+		redo: replayRows(store, redoActions, unlinked)
+	});
+}
+var pushSheetHistory = (store, history) => (actions) => {
+	safeCallback(pushSheet, store, history, actions);
+};
+//#endregion
+export { isDictionaryAction, pushHistory, pushSheetHistory, pushStreamHistoryMap, pushUndoHistoryMap };

package/dist/engine/history.d.ts

@@ -1,9 +1,12 @@
 import { AnyAction } from '@dineug/r-html';
+import { RootState } from './state';
 type Dispatch = (actions: AnyAction[]) => void;
 type GetNextVersion = () => number;
+type GetState = () => RootState;
+export type Replay = (dispatch: Dispatch, getNextVersion: GetNextVersion, getState?: GetState) => void;
 export type Command = {
-    undo: (dispatch: Dispatch, getNextVersion: GetNextVersion) => void;
-    redo: (dispatch: Dispatch, getNextVersion: GetNextVersion) => void;
+    undo: Replay;
+    redo: Replay;
 };
 export type CommandKey = keyof Command;
 export type History = {
@@ -26,12 +29,17 @@ export type HistoryOptions = {
     notify: (has: HasHistory) => void;
     dispatch: Dispatch;
     getNextVersion: GetNextVersion;
+    /**
+     * The state of the store a replay dispatches into, which a command reads, so
+     * a clone replaying into another store reads that store's.
+     */
+    getState?: GetState;
 };
 type HistoryState = {
     commands: Command[];
     cursor: number;
     limit: number;
 };
-export declare function createHistory({ notify, dispatch, getNextVersion }: HistoryOptions, initialState?: HistoryState): History;
+export declare function createHistory({ notify, dispatch, getNextVersion, getState }: HistoryOptions, initialState?: HistoryState): History;
 export {};
 //# sourceMappingURL=history.d.ts.map

package/dist/engine/history.js

@@ -0,0 +1,72 @@
+//#region src/engine/history.ts
+function createHistory({ notify, dispatch, getNextVersion, getState }, initialState) {
+	let commands = initialState?.commands ?? [];
+	let cursor = initialState?.cursor ?? -1;
+	let limit = initialState?.limit ?? 0;
+	let executable = true;
+	const hasUndo = () => cursor !== -1;
+	const hasRedo = () => cursor < commands.length - 1;
+	const setLimit = (newLimit) => limit = newLimit;
+	const getHas = () => ({
+		hasRedo: hasRedo(),
+		hasUndo: hasUndo()
+	});
+	const execute = (command, key) => {
+		executable = false;
+		command[key](dispatch, getNextVersion, getState);
+		executable = true;
+	};
+	const push = (command) => {
+		if (!executable) return;
+		commands.splice(cursor + 1, commands.length - cursor);
+		commands.push(command);
+		if (limit !== 0 && commands.length > limit) commands = commands.slice(commands.length - limit, commands.length);
+		cursor = commands.length - 1;
+		notify(getHas());
+	};
+	const undo = () => {
+		if (!hasUndo()) return;
+		const command = commands[cursor];
+		execute(command, "undo");
+		cursor--;
+		notify(getHas());
+	};
+	const redo = () => {
+		if (!hasRedo()) return;
+		const command = commands[cursor + 1];
+		execute(command, "redo");
+		cursor++;
+		notify(getHas());
+	};
+	const clear = () => {
+		const prevSize = commands.length;
+		commands = [];
+		cursor = -1;
+		prevSize > 0 && notify(getHas());
+	};
+	const clone = (options) => {
+		return createHistory(options, {
+			commands: [...commands],
+			cursor,
+			limit
+		});
+	};
+	return Object.freeze({
+		get cursor() {
+			return cursor;
+		},
+		get size() {
+			return commands.length;
+		},
+		hasUndo,
+		hasRedo,
+		push,
+		undo,
+		redo,
+		clear,
+		setLimit,
+		clone
+	});
+}
+//#endregion
+export { createHistory };

package/dist/engine/index.js

@@ -1,56 +1,2 @@
-import { $ as e, Jn as t, Vo as n, c as r, fs as i, mn as a, ms as o, n as s, r as c, t as l, u, v as d, y as f } from "../loadValue-BKvXDYoC.js";
-import { Observable as p, Subject as m, debounceTime as h, map as g } from "rxjs";
-import { omit as _ } from "es-toolkit";
-//#region src/engine/replication-store.ts
-var v = n(f), y = { change: "change" };
-function b(n) {
-	let b = /* @__PURE__ */ new Set(), x = u({
-		...n,
-		routes: !1
-	}), { clock: S } = x, C = c(x, !1);
-	C.dispatchSync(t({
-		width: 0,
-		height: 0
-	}));
-	let w = s(C), T = new m(), E = new p((e) => C.subscribe((t) => e.next(t))).pipe(r(f), h(200)), D = /* @__PURE__ */ new Set(), O = null, k = (e) => (D.has(e) || D.add(e), () => {
-		D.delete(e);
-	}), A = (e, t) => {
-		D.forEach((n) => {
-			let r = Reflect.get(n, e);
-			a(r, t);
-		});
-	}, j = (t) => {
-		O = null, C.dispatchSync(e(l(t)));
-	}, M = (e) => {
-		T.next([e].flat());
-	};
-	return b.add(E.subscribe(() => {
-		let e = i(C.state), t = O !== null && e !== O;
-		O !== null && (O = e), A(y.change, {
-			value: e,
-			changed: t
-		});
-	})).add(T.pipe(r(d), g((e) => e.map((e) => _(e, ["tags"])))).subscribe((e) => {
-		e.some(({ type: e }) => v(e)) && (O ??= i(C.state));
-		let t = S.getNextVersion();
-		e.forEach((e) => e.version ??= t), C.dispatchSync(e), e.forEach((e) => S.merge(e.version));
-	})), Object.freeze({
-		get value() {
-			return i(C.state);
-		},
-		get runtimeValue() {
-			return o(C.state);
-		},
-		on: k,
-		setInitialValue: j,
-		dispatch: (e) => {
-			queueMicrotask(() => M(e));
-		},
-		dispatchSync: M,
-		destroy: () => {
-			Array.from(b).forEach((e) => e.unsubscribe()), b.clear(), D.clear(), C.destroy(), w.destroy();
-		}
-	});
-}
-//#endregion
-export { b as createReplicationStore };
+import { createReplicationStore } from "./replication-store.js";
+export { createReplicationStore };

package/dist/engine/modules/dictionary/actions.d.ts

@@ -0,0 +1,74 @@
+import { Reducer } from '@dineug/r-html';
+import { EngineContext } from '../../context';
+import { RootState } from '../../state';
+import { Domain, Term, ValuesType, Word } from '../../../internal-types';
+export declare const ActionType: {
+    readonly addDictionary: "dictionary.add";
+    readonly updateDictionary: "dictionary.update";
+    readonly removeDictionary: "dictionary.remove";
+};
+export type ActionType = ValuesType<typeof ActionType>;
+/** The three dictionaries a document holds, each a sheet of rows. */
+export declare const DictionaryKind: {
+    readonly word: "word";
+    readonly term: "term";
+    readonly domain: "domain";
+};
+export type DictionaryKind = ValuesType<typeof DictionaryKind>;
+export declare const DictionaryKindList: ReadonlyArray<DictionaryKind>;
+/** What a row of each dictionary holds besides its id and its place in its sheet. */
+export type DictionaryValues = {
+    [DictionaryKind.word]: Omit<Word, 'id' | 'order'>;
+    [DictionaryKind.term]: Omit<Term, 'id' | 'order'>;
+    [DictionaryKind.domain]: Omit<Domain, 'id' | 'order'>;
+};
+/** What an action writes into a row: its values and its order key, which places it in its sheet. */
+export type DictionaryStoredValues = {
+    [K in DictionaryKind]: DictionaryValues[K] & {
+        order: string;
+    };
+};
+/**
+ * The fields of each dictionary's rows, in the order a reducer writes them.
+ * Every field is a string, and each is a register of its own.
+ */
+export declare const DictionaryFields: {
+    readonly word: readonly ["name", "abbreviation", "englishName", "description", "synonyms", "forbiddenWords"];
+    readonly term: readonly ["name", "physicalName", "domainId", "description", "synonyms"];
+    readonly domain: readonly ["name", "category", "dataType", "description"];
+};
+/**
+ * The fields a reducer writes, a register each: the values and the order key,
+ * which no sheet column, file column or tool shows.
+ */
+export declare const DictionaryStoredFields: {
+    readonly word: readonly ["name", "abbreviation", "englishName", "description", "synonyms", "forbiddenWords", "order"];
+    readonly term: readonly ["name", "physicalName", "domainId", "description", "synonyms", "order"];
+    readonly domain: readonly ["name", "category", "dataType", "description", "order"];
+};
+/** One row of one dictionary, and the values an action writes into it. */
+export type DictionaryRowPayload = {
+    [K in DictionaryKind]: {
+        kind: K;
+        id: string;
+        values: Partial<DictionaryStoredValues[K]>;
+    };
+}[DictionaryKind];
+/** A row to list, with the values it starts with, none for a row brought back. */
+export type DictionaryAddPayload = {
+    [K in DictionaryKind]: {
+        kind: K;
+        id: string;
+        values?: Partial<DictionaryStoredValues[K]>;
+    };
+}[DictionaryKind];
+export type ActionMap = {
+    [ActionType.addDictionary]: DictionaryAddPayload;
+    [ActionType.updateDictionary]: DictionaryRowPayload;
+    [ActionType.removeDictionary]: {
+        kind: DictionaryKind;
+        id: string;
+    };
+};
+export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
+//# sourceMappingURL=actions.d.ts.map

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

@@ -0,0 +1,42 @@
+//#region src/engine/modules/dictionary/actions.ts
+var ActionType = {
+	addDictionary: "dictionary.add",
+	updateDictionary: "dictionary.update",
+	removeDictionary: "dictionary.remove"
+};
+var DictionaryKind = {
+	word: "word",
+	term: "term",
+	domain: "domain"
+};
+var DictionaryKindList = Object.values(DictionaryKind);
+var DictionaryFields = {
+	[DictionaryKind.word]: [
+		"name",
+		"abbreviation",
+		"englishName",
+		"description",
+		"synonyms",
+		"forbiddenWords"
+	],
+	[DictionaryKind.term]: [
+		"name",
+		"physicalName",
+		"domainId",
+		"description",
+		"synonyms"
+	],
+	[DictionaryKind.domain]: [
+		"name",
+		"category",
+		"dataType",
+		"description"
+	]
+};
+var DictionaryStoredFields = {
+	[DictionaryKind.word]: [...DictionaryFields.word, "order"],
+	[DictionaryKind.term]: [...DictionaryFields.term, "order"],
+	[DictionaryKind.domain]: [...DictionaryFields.domain, "order"]
+};
+//#endregion
+export { ActionType, DictionaryFields, DictionaryKind, DictionaryKindList, DictionaryStoredFields };

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

@@ -0,0 +1,74 @@
+import { EngineContext } from '../../context';
+import { RootState } from '../../state';
+import { Domain, Term, Word } from '../../../internal-types';
+import { DictionaryKind, ReducerType } from './actions';
+/** A kind this release knows; a later release's kind changes nothing here. */
+export declare const hasDictionaryKind: (kind: unknown) => kind is DictionaryKind;
+/** The row of a dictionary the id names, a removed one too. */
+export declare const selectDictionaryRow: (state: RootState, kind: DictionaryKind, id: string) => Word | Term | Domain | undefined;
+/**
+ * The ids of a dictionary's listed rows, in the order they were listed, which
+ * membership reads; a sheet shows them in key order (orderedDictionaryRows).
+ */
+export declare const dictionaryIds: (state: RootState, kind: DictionaryKind) => string[];
+/**
+ * The string values a payload names among the kind's fields, in their order,
+ * so a field or a value no editor sends is passed over.
+ */
+export declare function dictionaryEntries(kind: DictionaryKind, values: unknown): Array<[field: string, value: string]>;
+/**
+ * Measures the domain cell of every column linking the domain, a removed
+ * column's too, so each width reads the domain as it now stands whatever
+ * order a peer heard the domain's and the column's changes in.
+ */
+export declare function measureDomainColumns(state: RootState, domainId: string, { toWidth }: EngineContext): void;
+export declare const addDictionaryAction: {
+    (payload: import('./actions').DictionaryAddPayload): import('@dineug/r-html').AnyAction<import('./actions').DictionaryAddPayload>;
+    toString(): string;
+    type: string;
+};
+export declare const updateDictionaryAction: {
+    (payload: import('./actions').DictionaryRowPayload): import('@dineug/r-html').AnyAction<import('./actions').DictionaryRowPayload>;
+    toString(): string;
+    type: string;
+};
+export declare const removeDictionaryAction: {
+    (payload: {
+        kind: DictionaryKind;
+        id: string;
+    }): import('@dineug/r-html').AnyAction<{
+        kind: DictionaryKind;
+        id: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const dictionaryReducers: {
+    "dictionary.add": ReducerType<"dictionary.add">;
+    "dictionary.update": ReducerType<"dictionary.update">;
+    "dictionary.remove": ReducerType<"dictionary.remove">;
+};
+export declare const actions: {
+    addDictionaryAction: {
+        (payload: import('./actions').DictionaryAddPayload): import('@dineug/r-html').AnyAction<import('./actions').DictionaryAddPayload>;
+        toString(): string;
+        type: string;
+    };
+    updateDictionaryAction: {
+        (payload: import('./actions').DictionaryRowPayload): import('@dineug/r-html').AnyAction<import('./actions').DictionaryRowPayload>;
+        toString(): string;
+        type: string;
+    };
+    removeDictionaryAction: {
+        (payload: {
+            kind: DictionaryKind;
+            id: string;
+        }): import('@dineug/r-html').AnyAction<{
+            kind: DictionaryKind;
+            id: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
+};
+//# sourceMappingURL=atom.actions.d.ts.map