@dineug/erd-editor 4.0.0 → 4.2.0

package/dist/components/quick-search/scopedActions.d.ts

@@ -3,8 +3,6 @@ import { I18n } from '../../i18n/translate';
 import { FindField } from '../../utils/find-replace';
 import { Action } from './actions';
 import { PaletteQuery, PaletteScope } from './paletteQuery';
-/** How many rows a prefixed list shows, few enough to draw at once. */
-export declare const SCOPED_ACTION_LIMIT = 100;
 /** What the colon searches: the free text, never a name. */
 export declare const TEXT_FIELDS: FindField[];
 /**
@@ -19,16 +17,12 @@ export declare function scopeBase(actions: Action[], scope: PaletteScope | null)
  * read from the document for the columns, the free text and the help.
  */
 export declare function paletteRows(app: AppContext, found: Action[], { scope, keyword, table }: PaletteQuery, i18n?: I18n): Action[];
+/** The table rows the keyword fuzzes to, every one, those holding it as typed or by its Hangul letters first. */
+export declare function rankTableActions(found: Action[], keyword: string): Action[];
 /**
- * The table rows the keyword fuzzes to, those holding it as typed or by its
- * Hangul letters first, up to the scoped limit, past which a table whose name
- * the panel finds it in hands the search to Find and Replace over the names.
- */
-export declare function rankTableActions(app: AppContext, found: Action[], keyword: string, i18n?: I18n): Action[];
-/**
- * One row a field of the kinds given holding the keyword, Hangul letters too,
- * or every column or text, up to the scoped limit, past which one holding it as
- * typed hands it to Find and Replace over those kinds, without the table part.
+ * One row for each field of the kinds given holding the keyword, Hangul letters
+ * too, or for every column name or text that is not empty while there is none,
+ * the table part narrowing a column search; the list draws only the rows in view.
  */
 export declare function createFieldActions(app: AppContext, fields: FindField[], keyword: string, table?: string | null, i18n?: I18n): Action[];
 /** The prefixes as rows, each typing its character into the input when chosen; a keyword fuzzes them. */

package/dist/components/schema-sql/schema-sql-options/SchemaSQLOptions.d.ts

@@ -16,8 +16,8 @@ export type SchemaSQLOptionsProps = {
 };
 /**
  * The options beside the Schema SQL: the database and the bracket, then this
- * window's statements, header and tables, then the scripts the document
- * saves, and the buttons that save and copy the text.
+ * window's statements, header, logical name comments and tables, then the
+ * scripts the document saves, and the buttons that save and copy the text.
  */
 declare const SchemaSQLOptions: FC<SchemaSQLOptionsProps>;
 export default SchemaSQLOptions;

package/dist/components/schema-sql/schema-sql-options/SchemaSQLOptions.styles.d.ts

@@ -11,6 +11,8 @@ export declare const group: import('@dineug/r-html').CSSTemplateLiterals;
 /** A group under a rule, drawn halfway into the gap above it. */
 export declare const separated: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const row: import('@dineug/r-html').CSSTemplateLiterals;
+/** A label beside its switch: the label wraps, the switch keeps its size and the label takes the press. */
+export declare const toggle: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const column: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const caption: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const note: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/components/schema-sql/schemaSQLView.d.ts

@@ -19,6 +19,8 @@ export type SchemaSQLView = {
     statements: SchemaSQLStatements;
     /** The header asked for, resolved the same way. */
     header: SchemaSQLHeader;
+    /** Whether an empty comment writes the logical name; off at first. */
+    logicalNameAsComment: boolean;
     /** Replaced whole, never changed in place, so a watcher hears one change. */
     tables: SchemaSQLTableChoice;
     panel: OptionsPanelState;

package/dist/components/settings/lockSettingRows.d.ts

@@ -1,10 +1,11 @@
+import { LockSettingType as LockSettingBit } from '@dineug/erd-editor-schema';
 import { RootState } from '../../engine/state';
 import { I18n, PlainMessageKey } from '../../i18n/translate';
 type LockedValues = RootState['settings']['lockedValues'];
 type Translator = Pick<I18n, 't'>;
 export type LockSettingRow = {
     nameKey: PlainMessageKey;
-    lockSettingType: number;
+    lockSettingType: LockSettingBit;
     toText: (values: LockedValues, i18n: Translator) => string;
 };
 /**

package/dist/components/table-view/column/column-domain/ColumnDomain.d.ts

@@ -0,0 +1,19 @@
+import { FC, Ref } from '@dineug/r-html';
+import { AppContext } from '../../../appContext';
+export type ColumnDomainProps = {
+    app?: Ref<AppContext>;
+    tableId: string;
+    columnId: string;
+    width: number;
+    placeholder: string;
+    onBlur?: (event: FocusEvent) => void;
+    onEditEnd?: () => void;
+};
+/**
+ * The domain editor of a row: a search over the domain sheet by name that only
+ * picks, never writing what is typed. A pick links the domain with its type in
+ * one dispatch, and None unlinks; it opens on the row of the domain linked.
+ */
+declare const ColumnDomain: FC<ColumnDomainProps>;
+export default ColumnDomain;
+//# sourceMappingURL=ColumnDomain.d.ts.map

package/dist/components/table-view/column/column-domain/domainOptions.d.ts

@@ -0,0 +1,13 @@
+import { RootState } from '../../../../engine/state';
+/** A row of a domain picker: a domain by its id and name, or the empty id that unlinks. */
+export type DomainOption = {
+    id: string;
+    name: string;
+};
+/**
+ * The rows a search offers: every named domain in sheet order after the row
+ * that unlinks while nothing is typed, else the domains whose names hold the
+ * text in any case; none at all while the sheet lists no named domain.
+ */
+export declare function searchDomainOptions(state: RootState, typed: string): DomainOption[];
+//# sourceMappingURL=domainOptions.d.ts.map

package/dist/components/table-view/column/column-logical-name/ColumnLogicalName.d.ts

@@ -0,0 +1,22 @@
+import { FC, Ref } from '@dineug/r-html';
+import { AppContext } from '../../../appContext';
+export type ColumnLogicalNameProps = {
+    app?: Ref<AppContext>;
+    tableId: string;
+    /** The column whose logical name is edited, null for the table's own. */
+    columnId: string | null;
+    width: number;
+    value: string;
+    placeholder: string;
+    onInput?: (event: InputEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+    onEditEnd?: () => void;
+};
+/**
+ * The logical name editor of a header or a row: each key writes the text, the
+ * terms its start names drop under it, and a term picked writes it with its
+ * derivation; the name is derived once more as the editor closes on a change.
+ */
+declare const ColumnLogicalName: FC<ColumnLogicalNameProps>;
+export default ColumnLogicalName;
+//# sourceMappingURL=ColumnLogicalName.d.ts.map

package/dist/components/table-view/column/column-logical-name/ColumnLogicalName.styles.d.ts

@@ -0,0 +1,4 @@
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hint: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hintItem: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=ColumnLogicalName.styles.d.ts.map

package/dist/components/table-view/column/columnViewText.d.ts

@@ -0,0 +1,33 @@
+import { RootState } from '../../../engine/state';
+import { I18n, PlainMessageKey } from '../../../i18n/translate';
+import { Column } from '../../../internal-types';
+type ViewSettings = Pick<RootState['settings'], 'nameViewMode'>;
+type Names = {
+    name: string;
+    logicalName: string;
+};
+/** What a cell drawn in the DOM shows, the placeholder dimmed while the value is blank. */
+export type CellText = {
+    value: string;
+    placeholder: string;
+};
+/**
+ * What a logical name cell drawn in the DOM shows, as the canvas draws it: the
+ * logical name, or while it is blank the name in the logical view, that name's
+ * own placeholder while it is blank too, and in the view of both the logical name's.
+ */
+export declare function logicalNameCellText(settings: ViewSettings, { name, logicalName }: Names, nameKey: PlainMessageKey, { t }: Pick<I18n, 't'>): CellText;
+/** What the name cell of a row drawn in the DOM shows: the logical view puts the logical name there. */
+export declare function nameCellText(settings: ViewSettings, column: Names, i18n: Pick<I18n, 't'>): CellText;
+/**
+ * What the type cell of a row drawn in the DOM shows: the name of the listed
+ * domain it stands for in the logical view, else the type.
+ */
+export declare const typeCellText: (state: RootState, column: Pick<Column, "dataType" | "domainId">) => string;
+/**
+ * What the domain cell of a row drawn in the DOM holds: the listed domain's
+ * name, or nothing, over which the row dims the domain placeholder.
+ */
+export declare const domainCellText: (state: RootState, column: Pick<Column, "domainId">) => string;
+export {};
+//# sourceMappingURL=columnViewText.d.ts.map

package/dist/components/table-view/column/useHintList.d.ts

@@ -0,0 +1,24 @@
+export type HintListProps = {
+    onBlur?: (event: FocusEvent) => void;
+};
+/** The rows a list under a cell editor offers, and the one the keyboard is on, -1 for none. */
+export type HintListState = {
+    rows: ReadonlyArray<unknown>;
+    index: number;
+};
+/**
+ * The focus, pointer and scroll handling a cell editor with a list under its
+ * input shares with the data type cell: a press on the list keeps the caret,
+ * the wheel it scrolls by stays off the canvas, and the keyboard row stays in view.
+ */
+export declare function useHintList(props: HintListProps, state: HintListState): {
+    root: import('@dineug/r-html').Ref<HTMLDivElement>;
+    hintList: import('@dineug/r-html').Ref<HTMLDivElement>;
+    handleFocus: () => void;
+    handleFocusout: (event: FocusEvent) => void;
+    handleHintMousedown: (event: MouseEvent) => void;
+    handleHintTouchstart: (event: TouchEvent) => void;
+    handleHintWheel: (event: WheelEvent) => void;
+    step: (delta: 1 | -1) => void;
+};
+//# sourceMappingURL=useHintList.d.ts.map

package/dist/components/theme-builder/ThemeBuilder.styles.d.ts

@@ -1,7 +1,7 @@
 /**
- * A panel placed over whichever tab is up, padded as Find and Replace is. The
- * tab wrapper raises no stacking context, so a raised descendant would paint
- * over an unraised sibling; the same step later in the root keeps this on top.
+ * A panel placed over whichever tab is up. The tab wrapper raises no stacking
+ * context, so a raised descendant would paint over an unraised sibling; the
+ * same step later in the root keeps this on top.
  */
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const header: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/components/toolbar/Toolbar.styles.d.ts

@@ -1,5 +1,4 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const vertical: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const menu: import('@dineug/r-html').CSSTemplateLiterals;
-export declare const tableCount: import('@dineug/r-html').CSSTemplateLiterals;
 //# sourceMappingURL=Toolbar.styles.d.ts.map

package/dist/components/visualization/createVisualization.d.ts

@@ -15,6 +15,8 @@ export type VisualizationNode = {
     id: string;
     group: Group;
     name: string;
+    /** The logical name, which a table's label draws in the name views that show one. */
+    logicalName: string;
     /** The table a column hangs off; a table node has none. */
     tableId: string | null;
     x: number;

package/dist/components/visualization/flowLayout.d.ts

@@ -14,8 +14,9 @@ export declare function fitFlowView(store: RxStore): void;
  * @example
  * onMounted(() => ensureFlowPlaced(app.value));
  */
-export declare function ensureFlowPlaced(app: AppContext, { force }?: {
+export declare function ensureFlowPlaced(app: AppContext, { force, fit }?: {
     force?: boolean;
+    fit?: boolean;
 }): Promise<void>;
 /**
  * Keeps the Flow view placed for as long as the tab draws it: placed again

package/dist/components/visualization/table/column/Column.d.ts

@@ -6,6 +6,10 @@ export type ColumnProps = {
     widthDataType: number;
     widthDefault: number;
     widthComment: number;
+    /** The logical name's own cell, which the view of both names alone lays out. */
+    widthLogicalName?: number;
+    /** The domain's own cell, laid out while its show bit is set. */
+    widthDomain?: number;
     /** The room the table keeps for alternate key marks, 0 while it draws none. */
     widthAlternateKey?: number;
     /** The mark this row carries in that room, last, as the ERD scene draws it. */

package/dist/components/visualization/visualization-toolbar/VisualizationToolbar.d.ts

@@ -2,8 +2,8 @@ import { FC } from '@dineug/r-html';
 export type VisualizationToolbarProps = {};
 /**
  * The bar over the bottom of the Visualization tab: which of the two modes is
- * up, the zoom, the placement tools of the Flow, how much of a card it draws,
- * the way back to the whole document, and which way the content lies and how far once the screen holds none.
+ * up, the steps through the centers the Flow stood on, the zoom, its placement
+ * tools, how much of a card it draws, the way back to the whole document, and which way the content lies and how far once the screen holds none.
  */
 declare const VisualizationToolbar: FC<VisualizationToolbarProps>;
 export default VisualizationToolbar;

package/dist/components/visualization/visualizationView.d.ts

@@ -1,5 +1,6 @@
 import { ContentCompass } from '../erd/content-compass/compassGeometry';
 import { Viewport } from '../../engine/modules/editor/state';
+import { RootState } from '../../engine/state';
 import { Point } from '../../internal-types';
 import { Group, VisualizationLink, VisualizationNode } from './createVisualization';
 export { DIM_OPACITY } from '../../konva/scene/viewLayout';
@@ -13,10 +14,20 @@ export declare const NAME_MAX_LENGTH = 15;
  * truncateName('a_very_long_table_name'); // 'a_very_long_tab…'
  */
 export declare function truncateName(name: string): string;
-/** The text a table's label draws: its name cut to length, or the placeholder its input shows. */
-export declare function labelOf(node: Pick<VisualizationNode, 'name'>, placeholder: string): string;
-/** Whether a table has a name of its own, which is what its label is painted by. */
-export declare const hasName: (node: Pick<VisualizationNode, "name">) => boolean;
+type LabelNode = Pick<VisualizationNode, 'name' | 'logicalName'>;
+type ViewSettings = Pick<RootState['settings'], 'nameViewMode'>;
+/**
+ * The text a table's label draws in the name view: the name it shows cut to
+ * length, the name after the logical name on a second line in the view of
+ * both, or the placeholder its input shows while it shows no name.
+ */
+export declare function labelOf(node: LabelNode, placeholder: string, settings: ViewSettings): string;
+/**
+ * Whether a table's label draws a name of its own, which paints it in the
+ * foreground: not the placeholder, nor the name standing in for a blank
+ * logical name in the logical view.
+ */
+export declare function hasName(node: LabelNode, settings: ViewSettings): boolean;
 export declare const TABLE_RADIUS = 8;
 export declare const COLUMN_RADIUS = 4;
 /** A table draws larger than the columns that hang off it. */

package/dist/constants/layout.d.ts

@@ -47,6 +47,17 @@ export declare const TABLE_COLOR_WIDTH = 4;
 export declare const TABLE_HEADER_BUTTONS_WIDTH: number;
 export declare const COLUMN_DELETE_WIDTH = 12;
 export declare const COLUMN_KEY_WIDTH = 12;
+/** The button a column drag starts from, beside the focused row and outside the table. */
+export declare const COLUMN_DRAG_HANDLE_WIDTH = 16;
+export declare const COLUMN_DRAG_HANDLE_HEIGHT = 20;
+export declare const COLUMN_DRAG_HANDLE_ICON_SIZE = 12;
+/** The room between that button and the table's left edge. */
+export declare const COLUMN_DRAG_HANDLE_GAP = 4;
+/**
+ * The strip left of a table the handle answers a press in and a column drop is
+ * judged in, so a drag that runs straight down along the handle still reorders.
+ */
+export declare const COLUMN_DRAG_HANDLE_LANE = 24;
 /** The table icon before the name, at the key badge's size so the two stand in one column. */
 export declare const TABLE_HEADER_ICON_SIZE = 12;
 /** The gap after that icon, the one a key badge keeps, which lines the name up with the column names. */
@@ -141,7 +152,13 @@ export declare const TOOLBAR_DATABASE_NAME_WIDTH = 150;
 export declare const TABLE_PROPERTIES_BODY_PADDING = 12;
 /** How many rows the Table Properties index order shows before it scrolls the rest. */
 export declare const INDEX_ORDER_MAX_ROWS = 3;
-export declare const DIFF_TREE_WIDTH = 200;
+/** The Explorer's width as it first opens, and the width a double press on its edge gives back. */
+export declare const EXPLORER_WIDTH = 260;
+/** The narrowest and the widest a drag on the Explorer's edge sets it; narrower than the least, it hides. */
+export declare const EXPLORER_MIN_WIDTH = 200;
+export declare const EXPLORER_MAX_WIDTH = 480;
+/** The least of the canvas the Explorer leaves beside it, whatever its width asks. */
+export declare const EXPLORER_CANVAS_MIN_WIDTH = 320;
 /** The width of the options panel beside the code, on the Schema SQL and Code Generator tabs. */
 export declare const SCHEMA_SQL_PANEL_WIDTH = 300;
 /** An editor narrower than this opens the Schema SQL and Code Generator tabs with their panels folded away. */

package/dist/constants/open.d.ts

@@ -7,7 +7,6 @@ export declare const Open: {
     readonly localePicker: "localePicker";
     readonly diffViewer: "diffViewer";
     readonly timeTravel: "timeTravel";
-    readonly findReplace: "findReplace";
     readonly exportImage: "exportImage";
     readonly mapColumns: "mapColumns";
 };

package/dist/constants/schema.d.ts

@@ -5,6 +5,7 @@ export declare const CanvasType: {
     readonly schemaSQL: "@dineug/erd-editor/builtin-schema-sql";
     readonly generatorCode: "@dineug/erd-editor/builtin-generator-code";
     readonly settings: "settings";
+    readonly dictionary: "@dineug/erd-editor/builtin-dictionary";
 };
 export declare const CanvasTypeList: readonly string[];
 export declare const Show: {
@@ -21,6 +22,7 @@ export declare const Show: {
     readonly hideReferentialAction: 1024;
     readonly hideTableGroup: 2048;
     readonly hideMemo: 4096;
+    readonly columnDomain: 8192;
 };
 export declare const ColumnType: {
     readonly columnName: 1;
@@ -30,6 +32,8 @@ export declare const ColumnType: {
     readonly columnAutoIncrement: 16;
     readonly columnDefault: 32;
     readonly columnComment: 64;
+    readonly columnLogicalName: 128;
+    readonly columnDomain: 256;
 };
 export declare const ColumnTypeList: readonly number[];
 export declare const Database: {
@@ -115,6 +119,7 @@ export declare const ColumnOption: {
     readonly primaryKey: 2;
     readonly unique: 4;
     readonly notNull: 8;
+    readonly nameDerived: 16;
 };
 export declare const ColumnUIKey: {
     readonly primaryKey: 1;
@@ -132,9 +137,17 @@ export declare const LockSettingType: {
     readonly tableNameCase: 8;
     readonly columnNameCase: 16;
     readonly bracketType: 32;
+    readonly unlockNameViewMode: 64;
 };
-export declare const LockSettingTypeList: readonly number[];
-export declare const LockSettingFields: Readonly<Record<number, readonly ("zoomLevel" | "canvasType" | "language" | "bracketType" | "originX" | "originY" | "tableNameCase" | "columnNameCase")[]>>;
+export declare const LockSettingTypeList: readonly import('@dineug/erd-editor-schema').LockSettingType[];
+export declare const LockSettingFields: Readonly<Record<number, readonly ("canvasType" | "language" | "tableNameCase" | "columnNameCase" | "bracketType" | "zoomLevel" | "originX" | "originY" | "nameViewMode")[]>>;
+export declare const InvertedLockSettings: number;
+export declare const NameViewMode: {
+    readonly physical: "physical";
+    readonly logical: "logical";
+    readonly both: "both";
+};
+export declare const NameViewModeList: ReadonlyArray<ValuesType<typeof NameViewMode>>;
 export declare const CANVAS_SIZE_MAX: 20000;
 export declare const CANVAS_SIZE_MIN: 2000;
 export declare const CANVAS_ZOOM_MAX: 1.5;

package/dist/engine/actions.d.ts

@@ -1,3 +1,6 @@
+import { ActionMap as DictionaryActionMap } from './modules/dictionary/actions';
+import { actions as dictionaryActions } from './modules/dictionary/atom.actions';
+import { actions$ as dictionaryActions$ } from './modules/dictionary/generator.actions';
 import { ActionMap as EditorActionMap } from './modules/editor/actions';
 import { actions as editorActions } from './modules/editor/atom.actions';
 import { actions$ as editorActions$ } from './modules/editor/generator.actions';
@@ -25,8 +28,8 @@ import { actions$ as tableColumnActions$ } from './modules/table-column/generato
 import { ActionMap as TableGroupActionMap } from './modules/table-group/actions';
 import { actions as tableGroupActions } from './modules/table-group/atom.actions';
 import { actions$ as tableGroupActions$ } from './modules/table-group/generator.actions';
-export type Actions = typeof editorActions & typeof editorActions$ & typeof indexActions & typeof indexActions$ & typeof indexColumnActions & typeof indexColumnActions$ & typeof memoActions & typeof memoActions$ & typeof relationshipActions & typeof relationshipActions$ & typeof settingsActions & typeof settingsActions$ & typeof tableActions & typeof tableActions$ & typeof tableColumnActions & typeof tableColumnActions$ & typeof tableGroupActions & typeof tableGroupActions$;
-export type RootActionMap = EditorActionMap & TableActionMap & TableColumnActionMap & MemoActionMap & RelationshipActionMap & SettingsActionMap & IndexActionMap & IndexColumnActionMap & TableGroupActionMap;
+export type Actions = typeof editorActions & typeof editorActions$ & typeof indexActions & typeof indexActions$ & typeof indexColumnActions & typeof indexColumnActions$ & typeof memoActions & typeof memoActions$ & typeof relationshipActions & typeof relationshipActions$ & typeof settingsActions & typeof settingsActions$ & typeof tableActions & typeof tableActions$ & typeof tableColumnActions & typeof tableColumnActions$ & typeof tableGroupActions & typeof tableGroupActions$ & typeof dictionaryActions & typeof dictionaryActions$;
+export type RootActionMap = EditorActionMap & TableActionMap & TableColumnActionMap & MemoActionMap & RelationshipActionMap & SettingsActionMap & IndexActionMap & IndexColumnActionMap & TableGroupActionMap & DictionaryActionMap;
 export type ActionType = keyof RootActionMap;
 export declare const actions: Actions;
 export declare const ChangeActionTypes: ReadonlyArray<ActionType>;

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.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/index.js

@@ -1,45 +1,45 @@
-import { $ as e, Bo as t, Jn as n, c as r, ds as i, mn as a, n as o, ps as s, r as c, t as l, u, v as d, y as f } from "../loadValue-B3EFSe9k.js";
+import { $ as e, In as t, c as n, fr as r, jc as i, kc as a, n as o, r as s, t as c, tc as l, u, v as d, y as f } from "../loadValue-B5ojYrZ-.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 = t(f), y = { change: "change" };
-function b(t) {
+var v = l(f), y = { change: "change" };
+function b(l) {
 	let b = /* @__PURE__ */ new Set(), x = u({
-		...t,
+		...l,
 		routes: !1
-	}), { clock: S } = x, C = c(x, !1);
-	C.dispatchSync(n({
+	}), { clock: S } = x, C = s(x, !1);
+	C.dispatchSync(r({
 		width: 0,
 		height: 0
 	}));
-	let w = o(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), () => {
+	let w = o(C), T = new m(), E = new p((e) => C.subscribe((t) => e.next(t))).pipe(n(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);
+	}), A = (e, n) => {
+		D.forEach((r) => {
+			let i = Reflect.get(r, e);
+			t(i, n);
 		});
 	}, j = (t) => {
-		O = null, C.dispatchSync(e(l(t)));
+		O = null, C.dispatchSync(e(c(t)));
 	}, M = (e) => {
 		T.next([e].flat());
 	};
 	return b.add(E.subscribe(() => {
-		let e = i(C.state), t = O !== null && e !== O;
+		let e = a(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));
+	})).add(T.pipe(n(d), g((e) => e.map((e) => _(e, ["tags"])))).subscribe((e) => {
+		e.some(({ type: e }) => v(e)) && (O ??= a(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);
+			return a(C.state);
 		},
 		get runtimeValue() {
-			return s(C.state);
+			return i(C.state);
 		},
 		on: k,
 		setInitialValue: j,

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