@dineug/erd-editor 4.1.0 → 4.2.0

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

@@ -0,0 +1,73 @@
+import { RootState } from '../../state';
+import { Domain, Term, Word } from '../../../internal-types';
+import { DictionaryKind } from './actions';
+/** The row each dictionary holds. */
+export type DictionaryRowOf = {
+    [DictionaryKind.word]: Word;
+    [DictionaryKind.term]: Term;
+    [DictionaryKind.domain]: Domain;
+};
+/**
+ * A name as every dictionary lookup compares it: trimmed and composed, its
+ * case kept, so a term matches a logical name typed in either Unicode form.
+ */
+export declare const normalizeDictionaryName: (name: string) => string;
+/** The names a comma separated field lists, each normalized, none empty. */
+export declare const splitDictionaryList: (text: string) => string[];
+/**
+ * Marks a dictionary as written, so each index built over it is built again
+ * on its next read. The add, update and remove reducers call it; a load
+ * brings new collections, which no index was built over yet.
+ */
+export declare function raiseDictionaryGeneration(state: RootState, kind: DictionaryKind): void;
+/**
+ * A dictionary's listed rows in the order its sheet, its file and every reader
+ * show them: by order key. Built once per write of the sheet; never mutate it.
+ */
+export declare const orderedDictionaryRows: <K extends DictionaryKind>(state: RootState, kind: K) => ReadonlyArray<DictionaryRowOf[K]>;
+/**
+ * A reader of what the build makes of a dictionary's listed rows in sheet
+ * order, kept until the sheet is written again (heldPerSheet).
+ */
+export declare function dictionaryCache<K extends DictionaryKind, T>(kind: K, build: (rows: ReadonlyArray<DictionaryRowOf[K]>) => T): (state: RootState) => T;
+/** A sheet's listed rows, and those of each normalized name, both in sheet order. */
+export type NameIndex<Row> = {
+    rows: ReadonlyArray<Row>;
+    byName: ReadonlyMap<string, ReadonlyArray<Row>>;
+};
+/** What a word sheet says of one text: the words so named, and those listing it. */
+export type WordMarks = {
+    words: Word[];
+    synonymOf: Word[];
+    forbiddenOf: Word[];
+};
+/** A node of the word trie, keyed by UTF-16 code unit. */
+export type WordTrieNode = {
+    next: Map<number, WordTrieNode>;
+    marks?: WordMarks;
+};
+/** The word sheet's names, and a trie over them, its synonyms and its forbidden words. */
+export type WordIndex = NameIndex<Word> & {
+    root: WordTrieNode;
+};
+/** The rows by name; a row without a name is in no group and matches nothing. */
+export declare const buildNameIndex: <Row extends {
+    name: string;
+}>(rows: ReadonlyArray<Row>) => NameIndex<Row>;
+/**
+ * Marks each word's name, synonyms and forbidden words on the trie, in sheet
+ * order. A word without a name lists nothing, since it names no standard word
+ * to suggest, and a synonym equal to its own word's name is passed over.
+ */
+export declare function buildWordIndex(words: ReadonlyArray<Word>): WordIndex;
+/** The word sheet's index, built once per generation of the sheet. */
+export declare const getWordIndex: (state: RootState) => WordIndex;
+/** The term sheet's names, built once per generation of the sheet. */
+export declare const getTermNames: (state: RootState) => NameIndex<Term>;
+/** The domain sheet's names, built once per generation of the sheet. */
+export declare const getDomainNames: (state: RootState) => NameIndex<Domain>;
+/** The first listed term of the name, compared trimmed, composed and case kept. */
+export declare const findTerm: (state: RootState, name: string) => Term | undefined;
+/** The first listed domain of the name, compared as a term's is. */
+export declare const findDomain: (state: RootState, name: string) => Domain | undefined;
+//# sourceMappingURL=dictionaryIndex.d.ts.map

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

@@ -0,0 +1,9 @@
+import { RootState } from '../../state';
+/** The ids of the columns linking the domain, a removed column's among them; no column links ''. */
+export declare const domainColumnIds: (state: RootState, domainId: string) => ReadonlySet<string>;
+/**
+ * Moves the column from the domain it linked to the one it links now, in the
+ * index built over its collection; a collection with none builds it later.
+ */
+export declare function relinkDomainColumn(state: RootState, columnId: string, from: string, to: string): void;
+//# sourceMappingURL=domainLinks.d.ts.map

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

@@ -0,0 +1,27 @@
+import { AnyAction } from '@dineug/r-html';
+import { ChangeColumnValuePayload } from '../table-column/actions';
+import { RootState } from '../../state';
+/** What one dispatch writes that a column's data type or its domain follows. */
+export type DomainTypeWrites = {
+    /** The data type each domain takes, by the domain's id. */
+    domainTypes?: ReadonlyMap<string, string>;
+    /** The columns linked to a domain, its id as the value, '' to unlink. */
+    links?: ReadonlyArray<ChangeColumnValuePayload>;
+    /** The columns given a data type directly, as a type cell writes one. */
+    dataTypes?: ReadonlyArray<ChangeColumnValuePayload>;
+};
+/** A domain's type in one dispatch: the one it writes the domain, else the domain's own. */
+export declare function domainTypeIn(state: RootState, domainTypes: ReadonlyMap<string, string>): (id: string) => string;
+/**
+ * The unlinks that close a dispatch writing these column types: each column
+ * whose type then differs from the type of the domain it links, listed or
+ * removed, read with the domain types and links the same dispatch writes.
+ */
+export declare function toDomainUnlinkActions(state: RootState, written: ReadonlyArray<ChangeColumnValuePayload>, { domainTypes, links, }?: Pick<DomainTypeWrites, 'domainTypes' | 'links'>): AnyAction[];
+/**
+ * The column writes of one dispatch over all its rows: a column linked to a
+ * domain it changes or links takes that type first, the sync spreads from it
+ * without writing it again, and a written column off its domain's type unlinks.
+ */
+export declare function toDomainTypeActions(state: RootState, { domainTypes, links, dataTypes, }: DomainTypeWrites): AnyAction[];
+//# sourceMappingURL=domainTypes.d.ts.map

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

@@ -0,0 +1,63 @@
+import { AnyAction } from '@dineug/r-html';
+import { RootState } from '../../state';
+import { ValuesType } from '../../../internal-types';
+import { DictionaryCsvRow } from '../../../utils/dictionary-csv/dictionaryCsv';
+import { DictionaryKind, DictionaryValues } from './actions';
+/** A row a write names: a listed row by its id, or a new one with none. */
+export type DictionaryEntryChange<K extends DictionaryKind = DictionaryKind> = {
+    id?: string;
+    /** The values to write, and the order key, which only the engine sends, that places the row. */
+    values: Partial<DictionaryValues[K]> & {
+        order?: string;
+    };
+};
+/** Why a write of a dictionary row is turned away. */
+export declare const DictionaryRefusalCode: {
+    readonly duplicateName: "duplicateName";
+    readonly unknownDomain: "unknownDomain";
+};
+export type DictionaryRefusalCode = ValuesType<typeof DictionaryRefusalCode>;
+/**
+ * A row turned away: its position among the changes given, the name it would
+ * hold, and the text refused, the normalized name or the domain's id.
+ */
+export type DictionaryRefusal = {
+    code: DictionaryRefusalCode;
+    index: number;
+    name: string;
+    value: string;
+};
+/**
+ * Why each change would be turned away: a name another listed row of the
+ * sheet or another row of the same changes holds, compared normalized, or a
+ * term's domain the document does not list. An empty name is never refused.
+ */
+export declare function validateDictionaryValues<K extends DictionaryKind>(state: RootState, kind: K, changes: ReadonlyArray<DictionaryEntryChange<K>>): DictionaryRefusal[];
+/** What a commit sends: nothing while any row of it is refused. */
+export type DictionaryCommit = {
+    actions: AnyAction[];
+    refusals: DictionaryRefusal[];
+};
+/**
+ * The actions of a commit of rows, updates of listed rows and adds of new
+ * ones, with the columns its domains' new types reach, or none at all when a
+ * row is refused, so one commit lands whole or not.
+ */
+export declare function toDictionaryCommit<K extends DictionaryKind>(state: RootState, kind: K, changes: ReadonlyArray<DictionaryEntryChange<K>>): DictionaryCommit;
+/** What an import of a file's rows sends, and the counts its message shows. */
+export type DictionaryImport = {
+    actions: AnyAction[];
+    added: number;
+    updated: number;
+    /** The rows a later row of the same name replaced, or with no name. */
+    folded: number;
+    /** Each domain name a term row gives that the document lists no domain of. */
+    unknownDomains: string[];
+};
+/**
+ * Folds a file's rows by normalized name, the later row's values in the
+ * earlier one's place, then updates the listed row of each name and adds the
+ * rest. A term's domain is read by name, '' where no domain has it.
+ */
+export declare function toDictionaryImport<K extends DictionaryKind>(state: RootState, kind: K, rows: ReadonlyArray<DictionaryCsvRow<K>>): DictionaryImport;
+//# sourceMappingURL=entryWrites.d.ts.map

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

@@ -0,0 +1,126 @@
+import { GeneratorAction } from '../../generator.actions';
+import { ValuesType } from '../../../internal-types';
+import { DictionaryCsvRow } from '../../../utils/dictionary-csv/dictionaryCsv';
+import { DictionaryKind, DictionaryValues } from './actions';
+import { DictionaryEntryChange } from './entryWrites';
+/**
+ * Adds one row at the end of its sheet with the values given, none for an
+ * empty row; nothing when its name is another row's or its domain unknown.
+ */
+export declare const addDictionaryEntryAction$: <K extends DictionaryKind>(kind: K, values?: Partial<DictionaryValues[K]>) => GeneratorAction;
+/** Where inserted rows go: before or after a listed row, or at the end for none. */
+export type DictionaryInsertAnchor = {
+    id: string;
+    place: 'before' | 'after';
+} | null;
+/**
+ * Inserts empty rows before or after a row in one dispatch, at the end when it
+ * is gone, keying the rows around the place again where no key fits between
+ * them. Only the editor sends it, so it stays out of the barrel.
+ */
+export declare const insertDictionaryEntriesAction$: (kind: DictionaryKind, count: number, anchor?: DictionaryInsertAnchor) => GeneratorAction;
+/** Which way a sort runs. */
+export declare const DictionarySortDirection: {
+    readonly ascending: "ascending";
+    readonly descending: "descending";
+};
+export type DictionarySortDirection = ValuesType<typeof DictionarySortDirection>;
+/**
+ * Orders a sheet by one field for everyone in one dispatch, by the text a cell
+ * shows in the language given, numbers as numbers, empty cells last, ties as
+ * they stood; nothing for a sheet in that order. Only the editor sends it.
+ */
+export declare const sortDictionaryAction$: (kind: DictionaryKind, field: string, direction: DictionarySortDirection, locale?: string) => GeneratorAction;
+/**
+ * Writes the fields of a listed row that change, and the type of every column
+ * a domain's new type reaches; nothing when the row is refused or unlisted.
+ */
+export declare const updateDictionaryEntryAction$: <K extends DictionaryKind>(kind: K, id: string, values: Partial<DictionaryValues[K]>) => GeneratorAction;
+/**
+ * Removes each listed row named, once, in one dispatch, from the end of the
+ * list back, each after every named row behind it: removing a whole sheet or
+ * its tail moves no other row, while rows a scattered pick leaves still move.
+ */
+export declare const removeDictionaryEntriesAction$: (kind: DictionaryKind, ids: ReadonlyArray<string>) => GeneratorAction;
+/**
+ * A grid's commit: an update of each listed row named and an add of each row
+ * past the end, in one dispatch, or nothing at all when any row is refused.
+ */
+export declare const commitDictionaryCellsAction$: <K extends DictionaryKind>(kind: K, changes: ReadonlyArray<DictionaryEntryChange<K>>) => GeneratorAction;
+/**
+ * A file's rows, folded by name and upserted by name in one dispatch: only the
+ * adds and the fields that change, so the same file again sends nothing.
+ */
+export declare const importDictionaryAction$: <K extends DictionaryKind>(kind: K, rows: ReadonlyArray<DictionaryCsvRow<K>>) => GeneratorAction;
+/**
+ * Writes a column's logical name and what the dictionaries derive of it in
+ * one dispatch, the derivation only while the physical name is empty or
+ * derived; nothing when every value already holds.
+ */
+export declare const setColumnLogicalNameAction$: (tableId: string, columnId: string, value: string) => GeneratorAction;
+/**
+ * The logical names of several columns and what the dictionaries derive of
+ * them in one dispatch, as Replace All writes them; the domains they link are
+ * read over all of them at once, which separate generators would not do.
+ */
+export declare const setColumnLogicalNamesAction$: (names: ReadonlyArray<{
+    tableId: string;
+    columnId: string;
+    value: string;
+}>) => GeneratorAction;
+/** The table's logical name and its derived name, as a column's are. */
+export declare const setTableLogicalNameAction$: (tableId: string, value: string) => GeneratorAction;
+/** Derives a column's name from the logical name it holds, as its editor closes. */
+export declare const deriveColumnNameAction$: (tableId: string, columnId: string) => GeneratorAction;
+/** Derives a table's name from the logical name it holds, as its editor closes. */
+export declare const deriveTableNameAction$: (tableId: string) => GeneratorAction;
+/** What a derivation again covers. */
+export declare const RederiveScope: {
+    readonly column: "column";
+    readonly table: "table";
+    readonly selection: "selection";
+    readonly document: "document";
+};
+export type RederiveScope = ValuesType<typeof RederiveScope>;
+/**
+ * One column; one table, its name and every column; the selected tables so;
+ * or every table of the document so.
+ */
+export type RederiveNamesTarget = {
+    scope: typeof RederiveScope.column;
+    tableId: string;
+    columnId: string;
+} | {
+    scope: typeof RederiveScope.table;
+    tableId: string;
+} | {
+    scope: typeof RederiveScope.selection;
+} | {
+    scope: typeof RederiveScope.document;
+};
+/**
+ * Puts each name the target covers back under the dictionaries, its flag on,
+ * and derives it again, one dispatch and one undo; a name with no logical
+ * name, or a column whose new name another column holds, is left as it is.
+ */
+export declare const rederiveNamesAction$: (target: RederiveNamesTarget) => GeneratorAction;
+/**
+ * Links a column to a live domain and gives it the domain's type, the data
+ * type sync spreading it, in one dispatch; '' unlinks alone. A domain the
+ * document does not list links nothing.
+ */
+export declare const setColumnDomainAction$: (tableId: string, columnId: string, domainId: string) => GeneratorAction;
+export declare const actions$: {
+    addDictionaryEntryAction$: <K extends DictionaryKind>(kind: K, values?: Partial<DictionaryValues[K]>) => GeneratorAction;
+    updateDictionaryEntryAction$: <K extends DictionaryKind>(kind: K, id: string, values: Partial<DictionaryValues[K]>) => GeneratorAction;
+    removeDictionaryEntriesAction$: (kind: DictionaryKind, ids: ReadonlyArray<string>) => GeneratorAction;
+    importDictionaryAction$: <K extends DictionaryKind>(kind: K, rows: ReadonlyArray<DictionaryCsvRow<K>>) => GeneratorAction;
+    commitDictionaryCellsAction$: <K extends DictionaryKind>(kind: K, changes: ReadonlyArray<DictionaryEntryChange<K>>) => GeneratorAction;
+    setColumnLogicalNameAction$: (tableId: string, columnId: string, value: string) => GeneratorAction;
+    setTableLogicalNameAction$: (tableId: string, value: string) => GeneratorAction;
+    deriveColumnNameAction$: (tableId: string, columnId: string) => GeneratorAction;
+    deriveTableNameAction$: (tableId: string) => GeneratorAction;
+    rederiveNamesAction$: (target: RederiveNamesTarget) => GeneratorAction;
+    setColumnDomainAction$: (tableId: string, columnId: string, domainId: string) => GeneratorAction;
+};
+//# sourceMappingURL=generator.actions.d.ts.map

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

@@ -0,0 +1,14 @@
+import { AnyAction } from '@dineug/r-html';
+import { PushUndoHistory } from '../../history.actions';
+/**
+ * Turns round the adds and removes an undo sends, in the slots they hold: the
+ * undo of an import then takes its rows off the end of each list, and the undo
+ * of a removal sent from the end puts the rows back in their order.
+ */
+export declare function reverseDictionaryListings(undoActions: AnyAction[]): void;
+export declare const dictionaryPushUndoHistoryMap: {
+    "dictionary.add": PushUndoHistory;
+    "dictionary.update": PushUndoHistory;
+    "dictionary.remove": PushUndoHistory;
+};
+//# sourceMappingURL=history.d.ts.map

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

@@ -0,0 +1,28 @@
+import { RootState } from '../../state';
+/** Whether a dictionary's id list holds the id, without walking the list. */
+export declare const isListed: (list: string[], id: string) => boolean;
+/** Puts the id at the end of the list unless it holds it; true when it did. */
+export declare function listId(list: string[], id: string): boolean;
+/**
+ * Takes the id out of the list if it holds it; true when it did. It looks from
+ * the end, where a removal and an undo send their rows, since every element a
+ * splice moves in a state list goes through its proxy.
+ */
+export declare function unlistId(list: string[], id: string): boolean;
+/**
+ * The id while it names a domain the document lists, else '': what a paste
+ * links, since a copy from another document can name one this one lacks.
+ */
+export declare const toLiveDomainId: (state: RootState, domainId?: string) => string;
+/**
+ * The domain a pasted column keeps: a live one whose data type the column holds,
+ * else ''. A copy can name a domain whose type changed since it was taken, and a
+ * link off its domain's type would break the rule that a domain governs its type.
+ */
+export declare function toPastedDomainId(state: RootState, domainId: string | undefined, dataType: string): string;
+/**
+ * The name of the domain an id links, or '' while it links none in the
+ * document: a removed domain's name is kept for its undo and shown nowhere.
+ */
+export declare function getLiveDomainName(state: RootState, domainId: string): string;
+//# sourceMappingURL=membership.d.ts.map

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

@@ -0,0 +1,13 @@
+import { Ordered } from '@dineug/erd-editor-schema';
+/** The keys of the rows a placement adds, and the listed rows it keys again. */
+export type OrderPlacement = {
+    keys: string[];
+    rekeyed: Ordered[];
+};
+/**
+ * Keys for count new rows placed at index at of a sheet's rows in key order,
+ * rows.length for its end. Where no key fits between the neighbours, the rows
+ * around the place are keyed again with them, so the sheet reads as asked.
+ */
+export declare function placeOrderKeys(rows: ReadonlyArray<Ordered>, at: number, count: number): OrderPlacement;
+//# sourceMappingURL=orderKeys.d.ts.map

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

@@ -0,0 +1,24 @@
+import { Term } from '../../../internal-types';
+/** The most terms a logical name cell offers while it is typed. */
+export declare const TERM_COMPLETION_LIMIT = 8;
+/**
+ * The listed terms sorted by their keys in code unit order, one per name, the
+ * first listed answering for it; keys and terms share each position.
+ */
+export type TermIndex = {
+    keys: ReadonlyArray<string>;
+    terms: ReadonlyArray<Term>;
+};
+/** A term name or a typed prefix as completion compares it: composed and in lower case. */
+export declare const toTermKey: (text: string) => string;
+/** Sorts the named terms by key, a name in two cases ordered by the name itself. */
+export declare function buildTermIndex(terms: ReadonlyArray<Term>): TermIndex;
+/** The term sheet's completion index, built once per generation of the sheet. */
+export declare const getTermIndex: (state: import('../../state').RootState) => TermIndex;
+/**
+ * The terms whose names start with what is typed, at most the limit, in key
+ * order. A lower bound search finds the first key, so a query reads at most
+ * one key per halving, then one per term it gives and one that ends the run.
+ */
+export declare function completeTerms(index: TermIndex, typed: string, limit?: number): Term[];
+//# sourceMappingURL=termIndex.d.ts.map

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

@@ -1,9 +1,10 @@
 import { Reducer } from '@dineug/r-html';
 import { EngineContext } from '../../context';
+import { DictionaryKind } from '../dictionary/actions';
 import { RootState } from '../../state';
 import { LWW, Point, ValuesType } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
-import { FocusType, MoveKey, SelectType, SharedFocus, ShowMode, ViewKind, VisualizationMode } from './state';
+import { CenterStep, FocusType, MoveKey, SelectType, SharedFocus, ShowMode, ViewKind, VisualizationMode } from './state';
 export declare const ActionType: {
     readonly changeHasHistory: "editor.changeHasHistory";
     readonly selectAll: "editor.selectAll";
@@ -55,13 +56,23 @@ export declare const ActionType: {
     readonly viewSetLayout: "editor.viewSetLayout";
     readonly viewChangeShowMode: "editor.viewChangeShowMode";
     readonly viewSetCenters: "editor.viewSetCenters";
+    readonly viewStepCenters: "editor.viewStepCenters";
     readonly changeVisualizationMode: "editor.changeVisualizationMode";
 };
 export type ActionType = ValuesType<typeof ActionType>;
+/**
+ * Set on the clear and the load of a schema import, and of their undo, which
+ * leave the store's words, terms and domains and their lists as they are.
+ */
+export type DictionaryLoadFlag = {
+    keepDictionaries?: boolean;
+};
 export type ActionMap = {
     [ActionType.changeHasHistory]: {
         hasUndo: boolean;
         hasRedo: boolean;
+        /** The dictionary sheet whose history this is, none for the document's. */
+        sheet?: DictionaryKind;
     };
     [ActionType.selectAll]: void;
     [ActionType.unselectAll]: void;
@@ -70,8 +81,8 @@ export type ActionMap = {
         width: number;
         height: number;
     };
-    [ActionType.clear]: void;
-    [ActionType.loadJson]: {
+    [ActionType.clear]: DictionaryLoadFlag | void;
+    [ActionType.loadJson]: DictionaryLoadFlag & {
         value: string;
     };
     [ActionType.initialClear]: void;
@@ -206,6 +217,10 @@ export type ActionMap = {
         tableIds: string[];
         kind?: ViewKind;
     };
+    [ActionType.viewStepCenters]: {
+        step: CenterStep;
+        kind?: ViewKind;
+    };
     [ActionType.changeVisualizationMode]: {
         value: VisualizationMode;
     };

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

@@ -6,9 +6,11 @@ export declare const changeHasHistoryAction: {
     (payload: {
         hasUndo: boolean;
         hasRedo: boolean;
+        sheet?: import('../dictionary/actions').DictionaryKind;
     }): import('@dineug/r-html').AnyAction<{
         hasUndo: boolean;
         hasRedo: boolean;
+        sheet?: import('../dictionary/actions').DictionaryKind;
     }>;
     toString(): string;
     type: string;
@@ -40,14 +42,16 @@ export declare const changeViewportAction: {
     type: string;
 };
 export declare const clearAction: {
-    (payload: void): import('@dineug/r-html').AnyAction<void>;
+    (payload: void | import('./actions').DictionaryLoadFlag): import('@dineug/r-html').AnyAction<void | import('./actions').DictionaryLoadFlag>;
     toString(): string;
     type: string;
 };
+/** Whether a clear or a load carries the flag that keeps the dictionaries. */
+export declare const keepsDictionaries: (payload: unknown) => boolean;
 export declare const loadJsonAction: {
-    (payload: {
+    (payload: import('./actions').DictionaryLoadFlag & {
         value: string;
-    }): import('@dineug/r-html').AnyAction<{
+    }): import('@dineug/r-html').AnyAction<import('./actions').DictionaryLoadFlag & {
         value: string;
     }>;
     toString(): string;
@@ -337,6 +341,7 @@ export declare const editorReducers: {
     "editor.viewSetLayout": ReducerType<"editor.viewSetLayout">;
     "editor.viewChangeShowMode": ReducerType<"editor.viewChangeShowMode">;
     "editor.viewSetCenters": ReducerType<"editor.viewSetCenters">;
+    "editor.viewStepCenters": ReducerType<"editor.viewStepCenters">;
     "editor.changeVisualizationMode": ReducerType<"editor.changeVisualizationMode">;
     "editor.changeHasHistory": ReducerType<"editor.changeHasHistory">;
     "editor.selectAll": ReducerType<"editor.selectAll">;
@@ -496,6 +501,17 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    viewStepCentersAction: {
+        (payload: {
+            step: import('./state').CenterStep;
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            step: import('./state').CenterStep;
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
     changeVisualizationModeAction: {
         (payload: {
             value: import('./state').VisualizationMode;
@@ -509,9 +525,11 @@ export declare const actions: {
         (payload: {
             hasUndo: boolean;
             hasRedo: boolean;
+            sheet?: import('../dictionary/actions').DictionaryKind;
         }): import('@dineug/r-html').AnyAction<{
             hasUndo: boolean;
             hasRedo: boolean;
+            sheet?: import('../dictionary/actions').DictionaryKind;
         }>;
         toString(): string;
         type: string;
@@ -543,14 +561,14 @@ export declare const actions: {
         type: string;
     };
     clearAction: {
-        (payload: void): import('@dineug/r-html').AnyAction<void>;
+        (payload: void | import('./actions').DictionaryLoadFlag): import('@dineug/r-html').AnyAction<void | import('./actions').DictionaryLoadFlag>;
         toString(): string;
         type: string;
     };
     loadJsonAction: {
-        (payload: {
+        (payload: import('./actions').DictionaryLoadFlag & {
             value: string;
-        }): import('@dineug/r-html').AnyAction<{
+        }): import('@dineug/r-html').AnyAction<import('./actions').DictionaryLoadFlag & {
             value: string;
         }>;
         toString(): string;

package/dist/engine/modules/editor/generator.actions.d.ts

@@ -8,9 +8,17 @@ import { Rect } from '../../../konva/scene/metrics';
 import { Rect as DragRect } from '../../../utils/dragSelect';
 import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
 import { ClipboardPayload } from '../../../utils/table-clipboard';
+import { DictionaryLoadFlag } from './actions';
 import { MoveKey } from './state';
 import { CreateEntityActions } from './utils/duplicate';
-export declare const loadJsonAction$: (value: string) => GeneratorAction;
+/**
+ * Replaces the document. A schema import passes keepDictionaries, since its
+ * text holds no dictionary and the store's words, terms and domains stay.
+ *
+ * @example
+ * store.dispatch(loadJsonAction$(json, { keepDictionaries: true }));
+ */
+export declare const loadJsonAction$: (value: string, { keepDictionaries }?: DictionaryLoadFlag) => GeneratorAction;
 export declare const initialLoadJsonAction$: (value: string) => GeneratorAction;
 /**
  * One drag of the selection: the document groups and tables it carries, read at its first step and
@@ -56,9 +64,9 @@ export type SchemaAppend = CreateEntityActions & {
  */
 export declare function withGridPoints(json: string, state: RootState, ctx: EngineContext): string;
 /**
- * A document's tables, relationships, indexes and memos as new entities of this
- * one, made as a paste makes them with no field at its default sent, their block
- * a gap under the diagram. Null for unreadable text or a document holding nothing.
+ * A document's tables, relationships, indexes and memos as new entities here,
+ * made as a paste makes them, no field at its default and no domain link sent,
+ * a gap under the diagram. Null for unreadable text or a document of nothing.
  *
  * @example
  * const append = toSchemaAppend(state, json, 'grid', ctx);
@@ -125,21 +133,27 @@ export declare function withImportSettings(schema: Pick<ERDEditorSchemaV3, 'sett
 export declare function toSchemaImportJson(type: SchemaImportType, value: string, { settings }: RootState, ctx: EngineContext): string;
 /**
  * The load each of the four text imports runs: the parsed document replaces
- * this one, its tables at the points the grid gives them here.
+ * this one, its tables at the points the grid gives them here, while the
+ * words, terms and domains stay, since the text brings none.
  */
 export declare const loadSchemaAction$: (type: SchemaImportType, value: string) => GeneratorAction;
 export declare const loadSchemaSQLAction$: (value: string) => GeneratorAction;
 export declare const loadSchemaGraphQLAction$: (value: string) => GeneratorAction;
 export declare const loadSchemaDBMLAction$: (value: string) => GeneratorAction;
 export declare const loadSchemaAMLAction$: (value: string) => GeneratorAction;
-export declare const dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
+/**
+ * Lifts the focused column, or the whole selection while the focused column is
+ * one of two or more selected in its table, as a table's press lifts the
+ * selected tables.
+ */
+export declare const dragstartColumnAction$: () => GeneratorAction;
 /** A null targetId drops past the last row, which appends. */
 export declare const dragoverColumnAction$: (targetId: string | null, targetTableId: string) => GeneratorAction;
 export declare const columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;
 export declare const columnKeyHoverEndAction$: () => GeneratorAction;
 export declare const actions$: {
     focusFlowTableAction$: (tableIds: string[]) => GeneratorAction;
-    loadJsonAction$: (value: string) => GeneratorAction;
+    loadJsonAction$: (value: string, { keepDictionaries }?: DictionaryLoadFlag) => GeneratorAction;
     initialLoadJsonAction$: (value: string) => GeneratorAction;
     moveAllAction$: (movementX: number, movementY: number, source?: GeometrySource, gesture?: MoveAllGesture) => GeneratorAction;
     removeSelectedAction$: () => GeneratorAction;
@@ -158,7 +172,7 @@ export declare const actions$: {
     loadSchemaAMLAction$: (value: string) => GeneratorAction;
     appendSchemaAction$: (type: SchemaImportType, value: string) => GeneratorAction;
     appendSchemaJsonAction$: (json: string, layout?: AppendLayout) => GeneratorAction;
-    dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
+    dragstartColumnAction$: () => GeneratorAction;
     dragoverColumnAction$: (targetId: string | null, targetTableId: string) => GeneratorAction;
     columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;
     columnKeyHoverEndAction$: () => GeneratorAction;