@dineug/erd-editor 4.1.0 → 4.2.0

package/README.md

@@ -15,6 +15,8 @@ leaking styles either way. It is the same editor as [erd-editor.io](https://erd-
 
 - **Design** — tables, columns, memos and table groups, four relationship cardinalities, ON DELETE
   and ON UPDATE, alternate keys, Auto Layout
+- **Naming standards** — logical and physical names, physical names and data types derived from
+  word, term and domain dictionaries, which have their own tab with CSV import and export and checks
 - **Import** — SQL DDL, GraphQL SDL, DBML and AML from the menu or [`setSchema*`](#importing-a-schema),
   replacing the diagram or adding to it
 - **Export** — DDL for eight databases, also from `getSchemaSQL()`, code in 22 languages and ORMs,
@@ -86,7 +88,8 @@ export default {
 ### Script tag
 
 `dist/erd-editor.umd.js` bundles every dependency and worker, registers `<erd-editor>` and puts
-`setExportFileCallback`, `setImportFileCallback` and `createKeyBindingMap` on `window.ErdEditor`.
+`setExportFileCallback`, `setImportFileCallback`, `createKeyBindingMap` and `dictionaryRowChords`
+on `window.ErdEditor`.
 Its workers are `data:` URLs, so a strict CSP needs `worker-src data:`. Pin a version beyond a demo.
 
 ```html
@@ -124,7 +127,7 @@ An attribute is on when present with no value or `"true"`.
 | Method | Description |
 | --- | --- |
 | `setInitialValue(value)` | Load a document with no undo entry; `''` starts a new one. |
-| `getSchemaSQL(vendor?, options?)` | DDL for one of the eight databases, by default the document's. `options`: `statements` (`create`, `ifNotExists`, `recreate`), `header` (`none`, `use`, `createAndUse`). |
+| `getSchemaSQL(vendor?, options?)` | DDL for one of the eight databases, by default the document's. `options`: `statements` (`create`, `ifNotExists`, `recreate`), `header` (`none`, `use`, `createAndUse`), `logicalNameAsComment` (`true` writes a table's or column's logical name where its comment is empty). |
 | `setSchemaSQL(value, options?)`, `setSchemaGraphQL`, `setSchemaDBML`, `setSchemaAML` | Replace the document with parsed DDL, GraphQL SDL, DBML or AML, or append it ([Importing a schema](#importing-a-schema)). |
 | `setSchemaJSON(value, options?)` | Load an `.erd.json` document as `value` does, or append it. |
 | `setDiffValue(value)` | Diff another document over the ERD tab. |
@@ -152,7 +155,8 @@ An attribute is on when present with no value or `"true"`.
 - Save `value`. `runtimeValue` also keeps removed entities and only seeds a
   [collaborator](#collaboration).
 - `change` fires 200 ms after the last change, never under `readonly`, and never for scroll, zoom,
-  the open tab or the code settings while the document locks them, which a new document does.
+  the open tab, the name view or the code settings while the document locks them, which a new
+  document does.
 - A file written by hand or by another release can differ from `value` once loaded, so detect edits
   with a [replica](#headless-replica)'s `changed`, not by comparing bytes.
 
@@ -163,6 +167,9 @@ An attribute is on when present with no value or `"true"`.
 - `'grid'`, the default, lands at once in rows. `'auto'` lays the tables out as the Import menu does
   and returns a `Promise` that resolves when they land; a later load supersedes it.
 - `mode: 'append'` adds the tables below the diagram, as Import and Add does.
+- A replace by the four text methods keeps the document's word, term and domain dictionaries, which
+  the text cannot hold; a replacing `setSchemaJSON` takes the ones its document holds, as `value`
+  does.
 
 ### Theme and language
 
@@ -194,6 +201,10 @@ names. A chord is modifiers (`Shift`, `Alt`, `Control`, `Meta`, or `$mod` for Cm
 elsewhere) joined by `+` with a `KeyboardEvent.code` or `key`; a space separates the chords of a
 sequence, such as `KeyT KeyG`. Several defaults, search and find and replace among them, stop the
 keydown, so to leave `$mod+KeyF` to the page, call `setKeyBindingMap({ findReplace: [] })`.
+`dictionaryRowChords(map)` lists the chords the Dictionary tab's grid inserts and deletes rows by
+under a map: the one-press chords of `addColumn` and `removeColumn`, and those of `addColumn` with
+`Shift` held as well, for Insert above, which no binding names. A host that keeps its own hotkeys
+off the editor's keys takes both lists.
 
 ## Display language
 
@@ -229,7 +240,9 @@ setImportFileCallback(async ({ type, op, accept, mode }) => {
 ```
 
 Skip a `type` you do not handle: a replacing `setSchemaJSON()` empties the document on any other
-payload. Unset or `null`, the browser's download and file picker work.
+payload. Unset or `null`, the browser's download and file picker work. The Dictionary tab's Import
+CSV always opens the browser's file picker, since no `type` names CSV, and its Export CSV goes
+through the export callback.
 
 ## Headless replica
 

package/dist/components/dictionary/Dictionary.d.ts

@@ -0,0 +1,12 @@
+import { FC } from '@dineug/r-html';
+export type DictionaryProps = {
+    readonly: boolean;
+};
+/**
+ * The Dictionary tab: the sheet switch, the search and the row and file tools
+ * over a grid of the sheet shown, and its row count and selection under it.
+ * Every edit, paste or clear the grid commits is one dispatch and one undo.
+ */
+declare const Dictionary: FC<DictionaryProps>;
+export default Dictionary;
+//# sourceMappingURL=Dictionary.d.ts.map

package/dist/components/dictionary/Dictionary.styles.d.ts

@@ -0,0 +1,33 @@
+/** The bar, the sheet under it and the status line at the foot. */
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * The sheet switch, the search and the row and file tools, on one line while
+ * they fit and on more where they do not, since the tab clips what overflows
+ * it and a narrow pane would hide the tools. Each control stands 28px high.
+ */
+export declare const bar: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const segments: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const segment: import('@dineug/r-html').CSSTemplateLiterals;
+/** A sheet's row count beside its name, quieter than the name. */
+export declare const count: import('@dineug/r-html').CSSTemplateLiterals;
+/** The check sheet's count in the colour of the loudest check it holds. */
+export declare const countError: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const countWarning: import('@dineug/r-html').CSSTemplateLiterals;
+/** The search takes what the switch and the tools leave, up to a width that keeps it a field. */
+export declare const searchField: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const searchIcon: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const search: import('@dineug/r-html').CSSTemplateLiterals;
+/** Clears the search, shown while it holds text. */
+export declare const clear: import('@dineug/r-html').CSSTemplateLiterals;
+/** The row and file tools, pushed to the bar's end, a rule between the two groups. */
+export declare const tools: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const tool: import('@dineug/r-html').CSSTemplateLiterals;
+/** Delete, which reads as the one tool that takes rows away once it is under the pointer. */
+export declare const toolDanger: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const divider: import('@dineug/r-html').CSSTemplateLiterals;
+/** The grid fills what the bar and the status line leave. */
+export declare const sheet: import('@dineug/r-html').CSSTemplateLiterals;
+/** What to do on a sheet with no row, over the grid's empty cells and out of the pointer's way. */
+export declare const empty: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const status: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=Dictionary.styles.d.ts.map

package/dist/components/dictionary/checkCount.d.ts

@@ -0,0 +1,28 @@
+import { DictionaryCheck, DictionaryCheckLevel } from '../../engine/modules/dictionary/checks';
+/** What an idle period hands its task: how long it may run, and whether it waited past its timeout instead. */
+export type IdleBudget = Pick<IdleDeadline, 'didTimeout' | 'timeRemaining'>;
+/** How long an idle task may wait for the browser to go idle before it runs anyway. */
+export declare const IDLE_TIMEOUT_MS = 1000;
+/** How long a slice runs where the browser names no idle time: one that timed out, or a timer's. */
+export declare const SLICE_MS = 8;
+/** Runs a task once the browser is idle, or on a timer where it names no idle time, and hands back its cancel. */
+export declare function whenIdle(task: (budget: IdleBudget) => void): () => void;
+export type CheckCountOptions = {
+    /** The checks of the document a step at a time (walkDictionaryChecks). */
+    walk: () => Iterator<ReadonlyArray<DictionaryCheck>>;
+    /** Whether a count is still wanted: a slice that finds none drops the walk. */
+    wanted: () => boolean;
+    /** Takes the number of checks and the loudest of their levels once a walk ends. */
+    done: (count: number, mark: DictionaryCheckLevel | null) => void;
+};
+/**
+ * Counts the checks on idle, a slice per idle period: each takes steps until
+ * its time runs out, one at least, and the next goes on where it stopped, so
+ * a slice outlasts its period by one step at most. A restart drops a walk begun.
+ */
+export declare function createCheckCount({ walk, wanted, done }: CheckCountOptions): {
+    /** Counts afresh on the next idle period, once however many restarts come before it. */
+    restart(): void;
+    stop(): void;
+};
+//# sourceMappingURL=checkCount.d.ts.map

package/dist/components/dictionary/checkSheet.d.ts

@@ -0,0 +1,41 @@
+import { GridColumn } from '@dineug/grid';
+import { ErdTarget } from '../erd/goToErdTarget';
+import { DictionaryKind } from '../../engine/modules/dictionary/actions';
+import { DictionaryCheck } from '../../engine/modules/dictionary/checks';
+import { RootState } from '../../engine/state';
+import { I18n } from '../../i18n/translate';
+/** The check sheet's columns: what kind of check, what it is about, and what it found. */
+export declare const CheckColumn: {
+    readonly type: "type";
+    readonly target: "target";
+    readonly detail: "detail";
+};
+type Translator = Pick<I18n, 't' | 'locale'>;
+/**
+ * The check sheet's three columns, labelled in the reader's language and
+ * read-only in every document, since a check is read off the other sheets
+ * and the tables, never written.
+ */
+export declare function checkSheetColumns(widths?: Readonly<Record<string, number>>, i18n?: Pick<I18n, 't'>): GridColumn[];
+/** What a cell of the check sheet shows, nothing for a column the sheet lacks. */
+export declare function checkCellText(state: RootState, check: DictionaryCheck, columnId: string, i18n?: Translator): string;
+/** Where a check leads: a dictionary row's cell on its own sheet, or a table's or a column's cell on the ERD tab. */
+export type CheckDestination = {
+    kind: 'entry';
+    sheet: DictionaryKind;
+    id: string;
+    columnId: string;
+} | {
+    kind: 'erd';
+    target: ErdTarget;
+};
+/** The cell a check names: a dictionary row's by its field, a table's or a column's on the canvas, the name view left to the jump. */
+export declare function checkDestination({ target, field, }: DictionaryCheck): CheckDestination;
+/**
+ * The checks the sheet lists, in the order the document gives them, those
+ * whose three cells hold the search's text while it holds any. It walks the
+ * whole document unless handed the checks a caller already listed.
+ */
+export declare function checkRows(state: RootState, search?: string, i18n?: Translator, checks?: ReadonlyArray<DictionaryCheck>): ReadonlyArray<DictionaryCheck>;
+export {};
+//# sourceMappingURL=checkSheet.d.ts.map

package/dist/components/dictionary/dictionary-context-menu/DictionaryContextMenu.d.ts

@@ -0,0 +1,30 @@
+import { FC } from '@dineug/r-html';
+export type DictionaryContextMenuProps = {
+    /** The rows the selection covers, which Insert adds beside it and Delete removes. */
+    count: number;
+    /** The header of the column right clicked, which the sorts order by; null shows no sort. */
+    column: string | null;
+    /** The grid shows no row, so only Insert below and the file rows show. */
+    empty?: boolean;
+    /** The chord that inserts above in the grid, shown beside its row. */
+    insertAboveShortcut?: string;
+    /** The chord that inserts below in the grid, shown beside its row. */
+    insertShortcut?: string;
+    /** The chord that deletes in the grid, shown beside its row. */
+    deleteShortcut?: string;
+    onInsertAbove: () => void;
+    onInsertBelow: () => void;
+    onDeleteRows: () => void;
+    onSortAscending: () => void;
+    onSortDescending: () => void;
+    onImport: () => void;
+    onExport: () => void;
+};
+/**
+ * The menu a right click on an entry sheet's grid opens: as many rows as the
+ * selection covers inserted above or below it or removed, the sheet sorted by
+ * the column, and a CSV file in and out, as the bar's buttons do.
+ */
+declare const DictionaryContextMenu: FC<DictionaryContextMenuProps>;
+export default DictionaryContextMenu;
+//# sourceMappingURL=DictionaryContextMenu.d.ts.map

package/dist/components/dictionary/dictionaryCommit.d.ts

@@ -0,0 +1,83 @@
+import { CommitEvent, GridSelection, RejectEvent } from '@dineug/grid';
+import { AppContext } from '../appContext';
+import { DomainOption } from '../table-view/column/column-domain/domainOptions';
+import { DictionaryKind } from '../../engine/modules/dictionary/actions';
+import { RxStore } from '../../engine/rx-store';
+import { RootState } from '../../engine/state';
+import { I18n } from '../../i18n/translate';
+/** One row a commit writes: a listed row by its id, or null for one past the end. */
+export type ResolvedRow = {
+    id: string | null;
+    /** The text each column of the commit gives, by column id. */
+    cells: Readonly<Record<string, string>>;
+};
+/**
+ * The rows one grid shows, a list per version the tab hands it. An edit is read
+ * by the id of the row it opened on, which a peer's removal above cannot move,
+ * a paste or a clear by the rows of the version the grid last received.
+ */
+export type SheetRows = {
+    /** The newest version, the one the tab hands the grid next. */
+    readonly version: number;
+    /** The rows of the newest version. */
+    readonly ids: ReadonlyArray<string>;
+    /** The rows of the version the grid last received. */
+    readonly receivedIds: ReadonlyArray<string>;
+    /** The id of the active cell's row, null while that row shows none. */
+    readonly activeId: string | null;
+    /**
+     * Takes the rows a batch or a search left under the next version. With no
+     * edit open the active id becomes the row the grid's active cell will show;
+     * an open edit keeps the row it opened on.
+     */
+    bump(ids: ReadonlyArray<string>, editing?: boolean): number;
+    /** Notes the version the tab hands the grid as it renders; older rows are let go. */
+    receive(version: number): void;
+    /** Notes the active cell's row: the one onReady selects, and every one onSelectionChange reports. */
+    activate(row: number): void;
+    /**
+     * Reads the active id again from the rows the grid shows, unless an edit is
+     * open. The tab calls it as a key, a double click, a composition or an input
+     * reaches the grid, in the capture phase, before any of them opens an edit.
+     */
+    settle(editing: boolean): void;
+    /** The rows a commit writes, in row order, or none for an edit on no row. */
+    resolve(event: CommitEvent): ResolvedRow[];
+};
+export declare function createSheetRows(ids?: ReadonlyArray<string>): SheetRows;
+/** How many names a toast shows before it counts the rest in its number alone. */
+export declare const NAMES_SHOWN = 3;
+/**
+ * Says what the grid refused, under one key per reason so a press repeated
+ * shows one toast: a copy or a clear that did nothing is an error, while a
+ * paste whose columns ran past the last wrote the rest.
+ */
+export declare function reportGridRefusal({ emitter }: Pick<AppContext, 'emitter'>, { reason }: RejectEvent): void;
+/**
+ * The names a toast shows in the reader's language, each in its own direction
+ * under a right-to-left one, in a list that says no more than its items do,
+ * since the number before it counts the rows it leaves out.
+ */
+export declare function formatNames(i18n: Pick<I18n, 'locale' | 'dir'>, names: ReadonlyArray<string>): string;
+/**
+ * Sends a grid's commit as one dispatch and one undo, a term's domain read from
+ * its name, or nothing, with a toast saying why, when a row it names was
+ * removed meanwhile or any of its rows is refused.
+ */
+export declare function commitDictionaryCells({ store, emitter }: Pick<AppContext, 'store' | 'emitter'>, kind: DictionaryKind, rows: SheetRows, event: CommitEvent, i18n?: Pick<I18n, 'locale' | 'dir'>): boolean;
+/** The domain the active row's term links, '' for none or a removed one: the row a term's domain picker opens on. */
+export declare function activeTermDomain(state: RootState, rows: Pick<SheetRows, 'activeId'>): string;
+/**
+ * Links the term the picker's edit opened on to the domain picked, by its id,
+ * None unlinking whatever it linked, a removed domain too, in one dispatch and
+ * one undo; nothing for the link it holds, or with a toast for a peer's removal.
+ */
+export declare function commitTermDomain({ store, emitter }: Pick<AppContext, 'store' | 'emitter'>, rows: Pick<SheetRows, 'activeId'>, { id: domainId, name }: DomainOption, i18n?: Pick<I18n, 'locale' | 'dir'>): boolean;
+/** The ids of the rows a selection covers, among the rows the grid drew it over, each once in sheet order. */
+export declare function selectedRowIds(rows: Pick<SheetRows, 'receivedIds'>, selection: GridSelection): string[];
+/**
+ * Removes the rows a selection covers in one dispatch, so one undo lists them
+ * all again; the generator sends the removals from the end of the list back.
+ */
+export declare function removeSelectedRows(store: Pick<RxStore, 'dispatch'>, kind: DictionaryKind, rows: Pick<SheetRows, 'receivedIds'>, selection: GridSelection): boolean;
+//# sourceMappingURL=dictionaryCommit.d.ts.map

package/dist/components/dictionary/dictionaryFile.d.ts

@@ -0,0 +1,23 @@
+import { AppContext } from '../appContext';
+import { DictionaryKind } from '../../engine/modules/dictionary/actions';
+import { RootState } from '../../engine/state';
+import { I18n } from '../../i18n/translate';
+/** What the tab's file input takes: a dictionary comes in one format, whichever layout its header names. */
+export declare const DICTIONARY_FILE_ACCEPT = ".csv";
+/** The file format the buttons, the menu and the empty sheet's hint name, which no language translates. */
+export declare const DICTIONARY_FILE_FORMAT = "CSV";
+/**
+ * Imports a file into the dictionary its header names in one dispatch, reports
+ * the counts and answers that dictionary; null for a read-only document or a
+ * file no layout reads, which sends nothing and says so.
+ */
+export declare function importDictionaryFile({ store, emitter }: Pick<AppContext, 'store' | 'emitter'>, file: Blob, i18n?: Pick<I18n, 'locale' | 'dir'>): Promise<DictionaryKind | null>;
+/**
+ * A dictionary's listed rows in the editor's own CSV format, in the order its
+ * sheet shows them, whatever a search shows. A term names its domain by the
+ * domain's name, and nothing for one the document does not list.
+ */
+export declare function toDictionaryCsv(state: RootState, kind: DictionaryKind): string;
+/** Saves a dictionary as its own CSV file, named after the database and the sheet. */
+export declare function exportDictionarySheet(state: RootState, kind: DictionaryKind): void;
+//# sourceMappingURL=dictionaryFile.d.ts.map

package/dist/components/dictionary/dictionaryKeys.d.ts

@@ -0,0 +1,48 @@
+import { ValuesType } from '../../internal-types';
+import { KeyBindingMap, KeyBindingName, ShortcutOption } from '../../utils/keyboard-shortcut';
+/**
+ * The editor's chords a press in the Dictionary tab still hands on: the
+ * palette, undo and redo, which the tab runs on the sheet's own history, and
+ * find, whose chord works on every tab.
+ */
+export declare const DICTIONARY_PASSING_BINDINGS: ReadonlyArray<KeyBindingName>;
+/** What a press does to a sheet's rows in the grid. */
+export declare const RowCommand: {
+    readonly insertBelow: "insertBelow";
+    readonly insertAbove: "insertAbove";
+    readonly deleteRows: "deleteRows";
+};
+export type RowCommand = ValuesType<typeof RowCommand>;
+/** The chord a menu row shows for a row command, if one is bound. */
+export declare const rowChordOf: (keyBindingMap: KeyBindingMap, command: RowCommand) => string | undefined;
+/**
+ * Every chord the grid runs a row command by under the bindings given, Insert
+ * above's among them, which no binding names: what a host that keeps its own
+ * hotkeys off the editor's keys registers beside the binding map's.
+ */
+export declare const dictionaryRowChords: (keyBindingMap: KeyBindingMap) => ShortcutOption[];
+export type DictionaryKeyContext = {
+    keyBindingMap: KeyBindingMap;
+    /** Undoes the last edit of the sheet shown, from its own history. */
+    undo: () => void;
+    redo: () => void;
+    /** Whether the press came from inside the tab's grid. */
+    inGrid: boolean;
+    /** Whether the grid holds an open edit, whose own undo takes the press and which keeps the palette and find. */
+    isEditing: () => boolean;
+    /** Inserts as many rows below the selection as it covers. */
+    insertRows: () => void;
+    /** Inserts as many rows above the selection as it covers. */
+    insertRowsAbove: () => void;
+    /** Deletes the rows the selection covers. */
+    deleteRows: () => void;
+};
+/**
+ * Reads a press at the tab's root: undo and redo undo the sheet shown unless an
+ * edit or a field takes them, the row chords insert and delete rows in a grid
+ * with no edit open, which keeps find and the palette, and the rest stops.
+ */
+export declare function handleDictionaryKeydown(event: KeyboardEvent, { keyBindingMap, undo: undoSheet, redo: redoSheet, inGrid, isEditing, insertRows, insertRowsAbove, deleteRows, }: DictionaryKeyContext): void;
+/** Keeps a copy, a cut or a paste in the tab, which the editor root would read as a diagram's. */
+export declare const keepClipboard: (event: ClipboardEvent) => void;
+//# sourceMappingURL=dictionaryKeys.d.ts.map

package/dist/components/dictionary/dictionaryView.d.ts

@@ -0,0 +1,65 @@
+import { GridHandle, GridSelection } from '@dineug/grid';
+import { AppContext } from '../appContext';
+import { DictionarySheet } from './sheets';
+/** The first cell a sheet showed, the one a grid mounted again scrolls back to. */
+export type SheetScroll = {
+    row: number;
+    col: number;
+};
+/**
+ * What the tab keeps of one sheet across its mounts. The selection and the
+ * scroll count rows of the sheet as its search shows them. Each is frozen and
+ * replaced whole, so a watcher hears one change and a grid is handed no proxy.
+ */
+export type DictionarySheetView = {
+    search: string;
+    selection: Readonly<GridSelection> | null;
+    scroll: Readonly<SheetScroll> | null;
+    /** The widths a resize left, by column id. */
+    widths: Readonly<Record<string, number>>;
+};
+export type DictionaryView = {
+    sheet: DictionarySheet;
+    sheets: Record<DictionarySheet, DictionarySheetView>;
+};
+/**
+ * The window's own place in the Dictionary tab: never in the store, the file
+ * or a change event, kept until the element goes, one per editor. The tab
+ * mounts again on every visit and reads it back.
+ */
+export declare function dictionaryViewOf({ store, }: Pick<AppContext, 'store'>): DictionaryView;
+/**
+ * Writes a sheet's search. The rows it shows change with it, so the selection
+ * and the scroll it kept, which count those rows, are dropped.
+ */
+export declare function changeSearch(view: DictionaryView, sheet: DictionarySheet, search: string): void;
+/** Keeps the selection a grid reported or was handed, as a frozen copy. */
+export declare function rememberSelection(view: DictionaryView, sheet: DictionarySheet, selection: GridSelection): void;
+/**
+ * A selection held inside the rows and columns a grid has, every index cut to
+ * the last one and a range kept start before end; a grid with no rows keeps
+ * its first cell, where a row added comes up active.
+ */
+export declare function clampSelection(selection: Readonly<GridSelection>, rowCount: number, colCount: number): GridSelection;
+/** The first cell alone, what a sheet opens on before it has a selection of its own. */
+export declare const FIRST_CELL_SELECTION: Readonly<GridSelection>;
+/**
+ * The selection a grid mounted on the sheet is handed: the one it kept, held
+ * inside the rows it shows now, or the first cell. A fresh copy, since a grid
+ * holds what it is handed.
+ */
+export declare function storedSelection(view: DictionaryView, sheet: DictionarySheet, rowCount: number, colCount: number): GridSelection;
+/** Keeps the first cell a grid showed, from its viewport report, when it moved. */
+export declare function rememberScroll(view: DictionaryView, sheet: DictionarySheet, { rowStart, colStart }: {
+    rowStart: number;
+    colStart: number;
+}): void;
+/**
+ * Scrolls a grid back to the first cell its sheet showed. A grid scrolls the
+ * least distance that shows a cell, so it goes to the last cell first, and the
+ * way back up then stops with the kept cell first in view.
+ */
+export declare function restoreScroll(handle: Pick<GridHandle, 'scrollTo'>, view: DictionaryView, sheet: DictionarySheet, rowCount: number, colCount: number): void;
+/** Keeps the width a resize left a column at, which the grid draws only while the host holds it. */
+export declare function rememberWidth(view: DictionaryView, sheet: DictionarySheet, columnId: string, width: number): void;
+//# sourceMappingURL=dictionaryView.d.ts.map

package/dist/components/dictionary/domain-cell-editor/DomainCellEditor.d.ts

@@ -0,0 +1,22 @@
+import { EditorContext } from '@dineug/grid';
+import { FC } from '@dineug/r-html';
+import { DomainOption } from '../../table-view/column/column-domain/domainOptions';
+export type DomainCellEditorProps = {
+    editor: EditorContext;
+    /** The column's header, which names the search field. */
+    label: string;
+    /** The id of the domain the cell's row links, '' for none, which the list opens on. */
+    linkedId: string;
+    /** Links the row to the domain picked, by its id, '' for None. */
+    onPick: (option: DomainOption) => void;
+    /** Runs once its edit has closed, after onPick for a pick. */
+    onClose: () => void;
+};
+/**
+ * A term's domain cell editor: a search over the domain sheet by name that only
+ * picks, as the ERD tab's domain cell does. The grid's edit writes no text: a
+ * pick cancels it and hands the tab the domain picked by its id, None as ''.
+ */
+declare const DomainCellEditor: FC<DomainCellEditorProps>;
+export default DomainCellEditor;
+//# sourceMappingURL=DomainCellEditor.d.ts.map

package/dist/components/dictionary/domain-cell-editor/DomainCellEditor.styles.d.ts

@@ -0,0 +1,7 @@
+/** The height of one domain in the list. */
+export declare const OPTION_HEIGHT = 26;
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const input: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const list: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const option: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=DomainCellEditor.styles.d.ts.map

package/dist/components/dictionary/domain-cell-editor/openDomainCellEditor.d.ts

@@ -0,0 +1,9 @@
+import { EditorContext } from '@dineug/grid';
+import { DomainCellEditorProps } from './DomainCellEditor';
+/**
+ * Opens the domain picker of a term's domain cell in the grid's editor slot,
+ * and takes it out again once its edit has closed, by a pick or a cancel,
+ * before onClose runs.
+ */
+export declare function openDomainCellEditor(editor: EditorContext, { label, linkedId, onPick, onClose }: Omit<DomainCellEditorProps, 'editor'>): void;
+//# sourceMappingURL=openDomainCellEditor.d.ts.map

package/dist/components/dictionary/gridTheme.d.ts

@@ -0,0 +1,18 @@
+import { CellStyle, GridTheme } from '@dineug/grid';
+import { DictionaryCheckLevel } from '../../engine/modules/dictionary/checks';
+import { Theme } from '../../themes/tokens';
+/**
+ * The theme the tab hands its grid. The grid redraws on a new object, so the
+ * one handed before comes back while every colour still matches, and only a
+ * theme change, light to dark or a new accent, makes another.
+ */
+export declare function toGridTheme(theme: Theme, previous?: Readonly<GridTheme>): Readonly<GridTheme>;
+/** The style a sheet gives a cell the checks mark, by the loudest level they find. */
+export type CellMarks = Readonly<Record<DictionaryCheckLevel, Readonly<CellStyle>>>;
+/**
+ * Each level's text on its own fill, from the tab's four mark tokens: the
+ * error pair and the warning pair. The marks handed before come back while
+ * both pairs match, so the tab hands the grid a new style getter only then.
+ */
+export declare function toCellMarks(theme: Theme, previous?: CellMarks): CellMarks;
+//# sourceMappingURL=gridTheme.d.ts.map

package/dist/components/dictionary/sheets.d.ts

@@ -0,0 +1,65 @@
+import { GridColumn } from '@dineug/grid';
+import { AnyAction } from '@dineug/r-html';
+import { DictionaryFields, DictionaryKind } from '../../engine/modules/dictionary/actions';
+import { DictionaryCheckLevel } from '../../engine/modules/dictionary/checks';
+import { RootState } from '../../engine/state';
+import { I18n, PlainMessageKey } from '../../i18n/translate';
+import { ValuesType } from '../../internal-types';
+/**
+ * The tab's sheets in the order its bar lists them: the domains, the words
+ * and the terms, as a standard is built up, then their checks.
+ */
+export declare const DictionarySheet: {
+    readonly domain: "domain";
+    readonly word: "word";
+    readonly term: "term";
+    readonly check: "check";
+};
+export type DictionarySheet = ValuesType<typeof DictionarySheet>;
+export declare const DictionarySheetList: ReadonlyArray<DictionarySheet>;
+/** Whether the sheet lists a dictionary's own rows, which it edits, rather than the checks over them. */
+export declare const isEntrySheet: (sheet: DictionarySheet) => sheet is DictionaryKind;
+export declare const DictionarySheetLabelKey: Readonly<Record<DictionarySheet, PlainMessageKey>>;
+/** A field of a dictionary's rows, which is the id of its column on the sheet. */
+export type SheetField<K extends DictionaryKind = DictionaryKind> = (typeof DictionaryFields)[K][number];
+export type SheetColumnOptions = {
+    /** A read-only document makes every column read-only. */
+    readonly: boolean;
+    /** The widths a resize left, by column id, in place of each column's own. */
+    widths?: Readonly<Record<string, number>>;
+};
+/**
+ * A dictionary's columns, one per field in the order its rows hold them, each
+ * labelled in the reader's language. A term's domain column shows and takes
+ * the domain's name, which the commit reads back to the domain's id.
+ */
+export declare function sheetColumns(kind: DictionaryKind, { readonly, widths }: SheetColumnOptions, i18n?: Pick<I18n, 't'>): GridColumn[];
+/** The field a column of the sheet writes, or undefined for an id the sheet has no column of. */
+export declare function sheetField<K extends DictionaryKind>(kind: K, columnId: string): SheetField<K> | undefined;
+/**
+ * What a row's cell shows: the field as the row holds it, and for a term's
+ * domain the name of the domain it links while the document lists that one,
+ * else nothing; nothing too for an id with no row or a column the sheet lacks.
+ */
+export declare function sheetCellText(state: RootState, kind: DictionaryKind, id: string, columnId: string): string;
+/**
+ * How loud a row's cell shows what the checks find in it: an error, a warning,
+ * or null for nothing found, a column no check reads or an id with no row. It
+ * reads the dictionaries' indexes, so a draw marks only the cells it paints.
+ */
+export declare function sheetCellMark(state: RootState, kind: DictionaryKind, id: string, columnId: string): DictionaryCheckLevel | null;
+/** A text as a search compares it, composed and in lower case, so a match ignores both. */
+export declare const toSearchText: (text: string) => string;
+/**
+ * The ids of a sheet's rows, its listed rows in key order, those whose
+ * searched fields hold the search's text while it holds any; with no search
+ * the same frozen array comes back until the sheet is written.
+ */
+export declare function sheetRowIds(state: RootState, kind: DictionaryKind, search?: string): ReadonlyArray<string>;
+/**
+ * The sheets a batch raises: all four for a dictionary's write or a load,
+ * since a term shows its domain's name and the checks read every dictionary;
+ * the checks alone for a table's or a column's write or a name view switch.
+ */
+export declare function bumpedSheets(actions: ReadonlyArray<AnyAction>): ReadonlyArray<DictionarySheet>;
+//# sourceMappingURL=sheets.d.ts.map

package/dist/components/erd/automatic-table-placement/flowPlacement.d.ts

@@ -1,14 +1,14 @@
 import { AppContext } from '../../appContext';
 import { ElkLayoutPoint, ElkLayoutRequest } from '../../../services/elk-layout';
 /**
- * What a Flow placement of a document asks ELK, measured on a plain store of
- * its own with the editor's text measure, so nothing reaches the editor's
- * store. Null under two tables or with no relationship, the grid's cases.
+ * What a Flow placement of a document asks ELK, measured in the reader's name
+ * view on a plain store of its own with the editor's text measure, so nothing
+ * reaches the editor's store. Null under two tables or with no relationship, the grid's cases.
  *
  * @example
  * const request = createFlowRequest(app, json);
  */
-export declare function createFlowRequest({ toWidth }: AppContext, json: string): ElkLayoutRequest | null;
+export declare function createFlowRequest({ toWidth, store }: AppContext, json: string): ElkLayoutRequest | null;
 /**
  * Where each table of a document not loaded yet goes by Flow, measured from
  * the corner of the block the tables make, so the caller decides where that

package/dist/components/erd/canvas/EditOverlay.styles.d.ts

@@ -4,4 +4,10 @@
  * paints no underline of its own: the scene's rect keeps running under it.
  */
 export declare const cell: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * A tinted header's text color, on the input alone: the term list a logical
+ * name opens under it paints the table's background, so its text and keys
+ * keep the theme's colors, which read there.
+ */
+export declare const tinted: import('@dineug/r-html').CSSTemplateLiterals;
 //# sourceMappingURL=EditOverlay.styles.d.ts.map

package/dist/components/erd/canvas/sceneHit.d.ts

@@ -11,6 +11,11 @@ export type HitFunc = (context: Context, shape: Shape) => void;
 export declare const columnCellHit: Record<GeometrySource, HitFunc>;
 /** One of those per source, built once, for the reason columnCellHit is. */
 export declare const headerCellHit: Record<GeometrySource, HitFunc>;
+/**
+ * The column drag handle's box: a row high, from a little left of its button
+ * to the table's edge, so a press beside the button still takes the handle.
+ */
+export declare const columnDragHandleHit: HitFunc;
 /**
  * The whole 24 unit box of a lucide icon, answered by the first shape it draws.
  * A circle's origin is its centre, so its own position is what puts the box

package/dist/components/erd/canvas/sceneTokens.d.ts

@@ -55,6 +55,10 @@ export declare const HIGH_LEVEL_FONT_SIZES: readonly [20, 24, 28, 35, 60];
 export declare const TABLE_INSET: number;
 /** The radius Table.styles rounds a table box with. */
 export declare const TABLE_CORNER_RADIUS = 6;
+/** How much of the column drag handle shows while the pointer is off it. */
+export declare const COLUMN_DRAG_HANDLE_REST_OPACITY = 0.5;
+/** The corner the column drag handle's button is rounded by. */
+export declare const COLUMN_DRAG_HANDLE_RADIUS = 4;
 /** The 1.5px underline EditInput draws for a focused, edited or shared cell. */
 export declare const FOCUS_BORDER_HEIGHT = 1.5;
 /** What the ring outside a table box costs, as outline and box-shadow both do. */
@@ -122,6 +126,8 @@ export declare const HIT_FILL = "transparent";
 export declare function documentCardShadow(color: string | undefined): CardShadow | null;
 /** The hand a clickable scene node asks for, as the dom scene spelt it in css. */
 export declare const CURSOR_POINTER = "pointer";
+/** The open hand the column drag handle asks for under the pointer. */
+export declare const CURSOR_GRAB = "grab";
 /** The beam a textarea carried on its own, which a drawn body has to ask for. */
 export declare const CURSOR_TEXT = "text";
 /** What a node hands back on the way out, leaving the container its own cursor. */