@dineug/erd-editor 4.0.0 → 4.2.0

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

@@ -0,0 +1,74 @@
+import { EngineContext } from '../../context';
+import { RootState } from '../../state';
+import { Domain, Term, Word } from '../../../internal-types';
+import { DictionaryKind, ReducerType } from './actions';
+/** A kind this release knows; a later release's kind changes nothing here. */
+export declare const hasDictionaryKind: (kind: unknown) => kind is DictionaryKind;
+/** The row of a dictionary the id names, a removed one too. */
+export declare const selectDictionaryRow: (state: RootState, kind: DictionaryKind, id: string) => Word | Term | Domain | undefined;
+/**
+ * The ids of a dictionary's listed rows, in the order they were listed, which
+ * membership reads; a sheet shows them in key order (orderedDictionaryRows).
+ */
+export declare const dictionaryIds: (state: RootState, kind: DictionaryKind) => string[];
+/**
+ * The string values a payload names among the kind's fields, in their order,
+ * so a field or a value no editor sends is passed over.
+ */
+export declare function dictionaryEntries(kind: DictionaryKind, values: unknown): Array<[field: string, value: string]>;
+/**
+ * Measures the domain cell of every column linking the domain, a removed
+ * column's too, so each width reads the domain as it now stands whatever
+ * order a peer heard the domain's and the column's changes in.
+ */
+export declare function measureDomainColumns(state: RootState, domainId: string, { toWidth }: EngineContext): void;
+export declare const addDictionaryAction: {
+    (payload: import('./actions').DictionaryAddPayload): import('@dineug/r-html').AnyAction<import('./actions').DictionaryAddPayload>;
+    toString(): string;
+    type: string;
+};
+export declare const updateDictionaryAction: {
+    (payload: import('./actions').DictionaryRowPayload): import('@dineug/r-html').AnyAction<import('./actions').DictionaryRowPayload>;
+    toString(): string;
+    type: string;
+};
+export declare const removeDictionaryAction: {
+    (payload: {
+        kind: DictionaryKind;
+        id: string;
+    }): import('@dineug/r-html').AnyAction<{
+        kind: DictionaryKind;
+        id: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const dictionaryReducers: {
+    "dictionary.add": ReducerType<"dictionary.add">;
+    "dictionary.update": ReducerType<"dictionary.update">;
+    "dictionary.remove": ReducerType<"dictionary.remove">;
+};
+export declare const actions: {
+    addDictionaryAction: {
+        (payload: import('./actions').DictionaryAddPayload): import('@dineug/r-html').AnyAction<import('./actions').DictionaryAddPayload>;
+        toString(): string;
+        type: string;
+    };
+    updateDictionaryAction: {
+        (payload: import('./actions').DictionaryRowPayload): import('@dineug/r-html').AnyAction<import('./actions').DictionaryRowPayload>;
+        toString(): string;
+        type: string;
+    };
+    removeDictionaryAction: {
+        (payload: {
+            kind: DictionaryKind;
+            id: string;
+        }): import('@dineug/r-html').AnyAction<{
+            kind: DictionaryKind;
+            id: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
+};
+//# sourceMappingURL=atom.actions.d.ts.map

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

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

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

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

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

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

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