@dineug/erd-editor 4.0.0 → 4.2.0

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/DiffOutline.template.d.ts

@@ -0,0 +1,14 @@
+/** @jsxHost konva */
+export type DiffOutlineOptions = {
+    name: string;
+    stroke: string | null;
+    width: number;
+    height: number;
+    cornerRadius: number;
+};
+/**
+ * The outline a diff pane draws round a box standing at its group's origin,
+ * centred on the box's edge and taking no press; none while stroke is null.
+ */
+export declare const diffOutlineRect: ({ name, stroke, width, height, cornerRadius, }: DiffOutlineOptions) => import("@dineug/r-html/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=DiffOutline.template.d.ts.map

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,10 +55,16 @@ 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. */
 export declare const RING_WIDTH = 1;
+/** The outline a diff pane draws round an entity added, removed or only moved. */
+export declare const DIFF_OUTLINE_WIDTH = 2;
 /**
  * The drop shadow a view card sits on, deeper than any a document box casts.
  * The alpha is the shadow's own, since the minimap shadow token it borrows is
@@ -120,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. */

package/dist/components/erd/canvas/table/Table.d.ts

@@ -25,6 +25,12 @@ export type TableProps = {
      * reads the group list once for every table; a table drawn alone reads its own.
      */
     tableGroupId?: string;
+    /**
+     * Whether the cells write what the dictionaries' checks find in their colours,
+     * on unless the scene says otherwise. Only the document scene outside a diff
+     * pane draws them, and an export turns them off.
+     */
+    checkMarks?: boolean;
 };
 declare const Table: FC<TableProps>;
 export default Table;

package/dist/components/erd/canvas/table/blankLogicalName.d.ts

@@ -0,0 +1,19 @@
+import { RootState } from '../../../../engine/state';
+import { PlainMessageKey } from '../../../../i18n/translate';
+/** What a logical name cell shows, dimmed, while its logical name is blank. */
+export type BlankLogicalName = {
+    /** The name drawn in the logical name's place, '' while there is none to draw. */
+    standIn: string;
+    /** The placeholder shown while there is no stand-in. */
+    key: PlainMessageKey;
+};
+/**
+ * The logical view sets the logical name cell in the name's place, so a blank
+ * one shows the name, or the name's own placeholder while that is blank too.
+ * The view of both shows the logical name's placeholder beside the name.
+ *
+ * @example
+ * const { standIn, key } = blankLogicalName(settings, table.name, 'common.placeholder.table');
+ */
+export declare function blankLogicalName(settings: Pick<RootState['settings'], 'nameViewMode'>, name: string, nameKey: PlainMessageKey): BlankLogicalName;
+//# sourceMappingURL=blankLogicalName.d.ts.map

package/dist/components/erd/canvas/table/cellLayout.d.ts

@@ -4,8 +4,8 @@ import { Table } from '../../../../internal-types';
 import { Theme } from '../../../../themes/tokens';
 import { ColumnWidth } from '../../../../utils/calcTable';
 import { GeometrySource } from '../../../../utils/draw-relationship/geometrySource';
-/** The four widths a column row measures from its table; the rest are fixed. */
-export type ColumnCellWidths = Pick<ColumnWidth, 'comment' | 'dataType' | 'default' | 'name'>;
+/** The six widths a column row measures from its table; the rest are fixed. */
+export type ColumnCellWidths = Pick<ColumnWidth, 'comment' | 'dataType' | 'default' | 'domain' | 'logicalName' | 'name'>;
 /** One editable box on a table, positioned inside the table's own group. */
 export type CellSlot = {
     focusType: FocusType;
@@ -93,13 +93,13 @@ export declare function getWidthComment(state: RootState, table: Table): number;
 /**
  * The name and comment boxes past a header's table icon. One list feeds the
  * scene that draws them and the overlay that edits them, so an editor never
- * sits anywhere but on the text it replaces. A view draws the name alone.
+ * sits anywhere but on the text it replaces. A view draws the names alone.
  */
 export declare function getHeaderCellSlots(state: RootState, table: Table, source?: GeometrySource): CellSlot[];
 /**
  * The cells of one column row, in the order the settings put them and at the x
  * each lands on once the ones before it have taken their width. A view lays
- * out the name and the type and reads neither the show bits nor the order.
+ * out the cells its name view names and reads neither the show bits nor the order.
  */
 export declare function getColumnCellSlots(state: RootState, widths: ColumnCellWidths, source?: GeometrySource): ColumnCellSlot[];
 //# sourceMappingURL=cellLayout.d.ts.map