@dineug/erd-editor 4.1.0 → 4.2.0

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/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. */

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, 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 { $ 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 = n(f), y = { change: "change" };
-function b(n) {
+var v = l(f), y = { change: "change" };
+function b(l) {
 	let b = /* @__PURE__ */ new Set(), x = u({
-		...n,
+		...l,
 		routes: !1
-	}), { clock: S } = x, C = c(x, !1);
-	C.dispatchSync(t({
+	}), { clock: S } = x, C = s(x, !1);
+	C.dispatchSync(r({
 		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), () => {
+	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 o(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

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

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

@@ -0,0 +1,76 @@
+import { RootState } from '../../state';
+import { Column, Table, ValuesType } from '../../../internal-types';
+import { DictionaryKind } from './actions';
+import { DictionaryRowOf } from './dictionaryIndex';
+/** The seven checks the dictionaries run over the tables, columns and rows. */
+export declare const DictionaryCheckCode: {
+    readonly duplicateName: "duplicateName";
+    readonly unknownDomain: "unknownDomain";
+    readonly unregisteredWord: "unregisteredWord";
+    readonly forbiddenWord: "forbiddenWord";
+    readonly synonymWord: "synonymWord";
+    readonly physicalNameMismatch: "physicalNameMismatch";
+    readonly domainTypeMismatch: "domainTypeMismatch";
+};
+export type DictionaryCheckCode = ValuesType<typeof DictionaryCheckCode>;
+export declare const DictionaryCheckCodeList: ReadonlyArray<DictionaryCheckCode>;
+/** How loud a check shows: an error or a warning. */
+export declare const DictionaryCheckLevel: {
+    readonly error: "error";
+    readonly warning: "warning";
+};
+export type DictionaryCheckLevel = ValuesType<typeof DictionaryCheckLevel>;
+/**
+ * A name two rows share, a link to no listed domain and a forbidden word are
+ * errors; an unregistered word, a synonym, a physical name the term would not
+ * give and a type other than the linked domain's are warnings.
+ */
+export declare const DictionaryCheckLevelOf: Readonly<Record<DictionaryCheckCode, DictionaryCheckLevel>>;
+/** What a check is about: a table, a column or a dictionary row. */
+export type DictionaryCheckTargetKind = 'table' | 'column' | DictionaryKind;
+/** The cell a check marks, by the field it reads. */
+export type DictionaryCheckField = 'name' | 'logicalName' | 'domainId';
+/**
+ * One finding, read only since the walks hand the same one out again. The
+ * target's table id is '' for a dictionary row; suggestions are the standard
+ * words, the physical name or the type the dictionaries offer instead of the text.
+ */
+export type DictionaryCheck = Readonly<{
+    code: DictionaryCheckCode;
+    target: Readonly<{
+        kind: DictionaryCheckTargetKind;
+        id: string;
+        tableId: string;
+    }>;
+    field: DictionaryCheckField;
+    text: string;
+    suggestions: ReadonlyArray<string>;
+}>;
+/**
+ * The checks of a table, or of one of its cells when a field is given: the
+ * words of its logical name and the physical name its term gives. Each reads
+ * an index, so marking a cell walks no sheet.
+ */
+export declare const checkTable: (state: RootState, table: Table, field?: DictionaryCheckField) => DictionaryCheck[];
+/** The checks of a column, or of one of its cells: a table's two, its domain link and its type against that domain's. */
+export declare const checkColumn: (state: RootState, column: Column, field?: DictionaryCheckField) => DictionaryCheck[];
+/**
+ * The checks of a dictionary row, or of one of its cells: a name another row
+ * of its sheet holds, and for a term the words of its name and its domain.
+ */
+export declare function checkDictionaryRow<K extends DictionaryKind>(state: RootState, kind: K, row: DictionaryRowOf[K], field?: DictionaryCheckField): DictionaryCheck[];
+/** The loudest level among the checks, null for none: what one cell shows. */
+export declare function markOf(checks: ReadonlyArray<DictionaryCheck>): DictionaryCheckLevel | null;
+/**
+ * Every check of the document in the order listDictionaryChecks gives them,
+ * a sheet, a term, a table or a column at a time, so a caller can stop
+ * between two and go on while the state stays as it was.
+ */
+export declare function walkDictionaryChecks(state: RootState): Generator<ReadonlyArray<DictionaryCheck>, void, undefined>;
+/**
+ * Every check of the document, for the sheet that lists them: the words, the
+ * terms and the domains in sheet order, then each table and its columns in
+ * document order, each target checked again only once a value it read moved.
+ */
+export declare function listDictionaryChecks(state: RootState): DictionaryCheck[];
+//# sourceMappingURL=checks.d.ts.map

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

@@ -0,0 +1,54 @@
+import { RootState } from '../../state';
+import { Term, ValuesType, Word } from '../../../internal-types';
+import { WordIndex } from './dictionaryIndex';
+/** What a stretch of a logical name is to the word sheet. */
+export declare const WordTokenKind: {
+    readonly word: "word";
+    readonly synonym: "synonym";
+    readonly forbidden: "forbidden";
+    readonly unregistered: "unregistered";
+};
+export type WordTokenKind = ValuesType<typeof WordTokenKind>;
+/**
+ * A stretch of a logical name and the words it reads as: those so named for
+ * a word, those listing it for a synonym or a forbidden word, none for an
+ * unregistered stretch.
+ */
+export type WordToken = {
+    text: string;
+    kind: WordTokenKind;
+    words: ReadonlyArray<Word>;
+};
+/** The units of a logical name, which the separators bound and no word crosses. */
+export declare const splitNameUnits: (logicalName: string) => string[];
+/**
+ * Splits a logical name into units at the separators, then reads each unit
+ * from the left, taking the longest text the word sheet marks and never going
+ * back. What no text matches joins one unregistered stretch until a match.
+ */
+export declare function decompose(index: WordIndex, logicalName: string): WordToken[];
+/**
+ * Joins the words' abbreviations with underscores, trimmed, their case as
+ * typed and with no bound on the length; the first listed word of a name
+ * answers for it. Any other token, or a word with no abbreviation, gives null.
+ */
+export declare function compose(tokens: ReadonlyArray<WordToken>): string | null;
+/** The physical name the word sheet composes for a logical name; null with no word listed. */
+export declare function composeName(state: RootState, logicalName: string): string | null;
+/**
+ * What the dictionaries make of a logical name. A term's physical name is ''
+ * when the term holds none and the words compose none, so a caller writes no
+ * name then; its domain is '' unless the document lists it.
+ */
+export type DerivedPhysical = {
+    physicalName: string;
+    domainId: string;
+    term: Term | null;
+};
+/**
+ * The term of the logical name first, its physical name composed of words
+ * when it holds none, else the composition alone, else null. An empty term
+ * sheet matches no term, and an empty word sheet composes nothing.
+ */
+export declare function derivePhysical(state: RootState, logicalName: string): DerivedPhysical | null;
+//# sourceMappingURL=derive.d.ts.map

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

@@ -0,0 +1,23 @@
+import { AnyAction } from '@dineug/r-html';
+import { ChangeColumnValuePayload } from '../table-column/actions';
+import { RootState } from '../../state';
+import { Column, Table } from '../../../internal-types';
+/**
+ * The names each table's columns hold, as two names compare, by table then
+ * column id; a dispatch that names several columns moves it as it goes.
+ */
+export type ColumnNameLedger = Map<string, Map<string, string>>;
+/** A column's name writes, and the link to its term's domain for the caller to settle. */
+export type ColumnNameWrites = {
+    actions: AnyAction[];
+    link: ChangeColumnValuePayload | null;
+};
+/**
+ * What the dictionaries write into a column for the logical name given. A
+ * name another column of the table holds, or one an earlier column of the
+ * ledger's dispatch took, derives nothing: the column keeps name, flag and link.
+ */
+export declare function toColumnNameWrites(state: RootState, tableId: string, column: Column, logicalName: string, force?: boolean, ledger?: ColumnNameLedger): ColumnNameWrites;
+/** What the dictionaries write into a table's name for the logical name given. */
+export declare function toTableNameWrites(state: RootState, table: Table, logicalName: string, force?: boolean): AnyAction[];
+//# sourceMappingURL=derivedNames.d.ts.map