@dineug/erd-editor 4.0.0 → 4.2.0

package/dist/styles/scrollbar.styles.d.ts

@@ -1,6 +1,6 @@
 /**
  * Global, not scoped. The ::-webkit-scrollbar* pseudo elements have no element of their own to
- * hang a component class on, and .scrollbar is a hook class seven components opt into by
+ * hang a component class on, and .scrollbar is a hook class the scrolling panels opt into by
  * literal name (class=${['scrollbar', ...]}) — scoping it would rename it out from under them.
  */
 export declare const scrollbarStyle: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/themes/tokens.d.ts

@@ -40,6 +40,10 @@ export type Theme = {
     columnSelect: string;
     columnSelectHover: string;
     columnHover: string;
+    columnHandleBackground: string;
+    columnHandleBorder: string;
+    columnHandleHoverBackground: string;
+    columnHandleHoverBorder: string;
     relationshipHover: string;
     visualizationLink: string;
     visualizationColumn: string;
@@ -74,12 +78,25 @@ export type Theme = {
     keyPK: string;
     keyFK: string;
     keyPFK: string;
-    diffInsertBackground: string;
-    diffDeleteBackground: string;
-    diffCrossBackground: string;
+    treeBackground: string;
+    treeRowHover: string;
+    treeRowCurrent: string;
+    treeMuted: string;
+    treeMatch: string;
+    explorerBackground: string;
+    explorerBorder: string;
+    dictionaryErrorForeground: string;
+    dictionaryErrorBackground: string;
+    dictionaryWarningForeground: string;
+    dictionaryWarningBackground: string;
+    dictionaryBackground: string;
+    dictionaryHeaderBackground: string;
+    dictionaryGridLine: string;
+    dictionaryHeaderSelect: string;
     diffInsertForeground: string;
     diffDeleteForeground: string;
-    diffCrossForeground: string;
+    diffModifyForeground: string;
+    diffRenameForeground: string;
 };
 export declare const ThemeTokens: ReadonlyArray<keyof Theme>;
 /** The custom property one token is published under on :host. */

package/dist/utils/calcTable.d.ts

@@ -1,4 +1,5 @@
 import { EngineContext } from '../engine/context';
+import { FocusType } from '../engine/modules/editor/state';
 import { RootState } from '../engine/state';
 import { Table } from '../internal-types';
 import { GeometrySource } from './draw-relationship/geometrySource';
@@ -24,23 +25,38 @@ export declare function invalidateTableWidths(): void;
  * none, so only a table that shows one widens.
  */
 export declare function calcAlternateKeyWidth(table: Table, state: RootState): number;
+/**
+ * The width a document header gives the cell of a focus type: the comment at
+ * its clamp, and the logical name at its own width in the view of both names
+ * or, in the logical view, at the name's while it holds none, which that view draws.
+ */
+export declare function headerCellWidth(state: RootState, table: Table, focusType: FocusType): number;
 export declare function calcTableWidths(table: Table, state: RootState): ColumnWidth;
+/**
+ * The width of each cell a document row lays out in the view the settings
+ * show, at the widest row, 0 for a cell it leaves out. The name and the type
+ * are the cells in their places, which the logical view fills its own way.
+ */
 export type ColumnWidth = {
     width: number;
     /** The alternate key marks' room after a row's last cell, 0 while none is drawn. */
     alternateKey: number;
     name: number;
+    /** The logical name's own cell, which the view of both names alone lays out. */
+    logicalName: number;
     comment: number;
     dataType: number;
+    /** The domain's own cell, laid out while its show bit is set. */
+    domain: number;
     default: number;
     notNull: number;
     autoIncrement: number;
     unique: number;
 };
 /**
- * The width a view draws a table at: the header name, or the key badge with
- * the widest name and type among the rows given, whichever is wider. The rows
- * are the caller's to name, and the show bits and the column order are the document's, read by no view.
+ * The width a view draws a table at: the header names, or the key badge with
+ * the widest of each cell its name view lays out among the rows given, whichever is wider.
+ * The rows are the caller's to name, and no view reads the show bits or the column order.
  */
 export declare function calcViewTableWidths(table: Table, state: RootState, columnIds: string[]): ColumnWidth;
 /**
@@ -59,7 +75,7 @@ export declare function tableHeaderHeight(source?: GeometrySource): number;
 export declare function tableRowHeight(source?: GeometrySource): number;
 /** The box height for the rows given, every row of the table unless a view shows fewer. */
 export declare function calcTableHeight(table: Table, rowCount?: number, source?: GeometrySource): number;
-export declare function recalculateTableWidth({ doc: { tableIds }, collections }: RootState, { toWidth }: EngineContext): void;
+export declare function recalculateTableWidth(state: RootState, { toWidth }: EngineContext): void;
 /**
  * The box a table takes on the ERD canvas once toWidth has measured its text,
  * the size recalculateTableWidth would leave it at. It works on copies, so it

package/dist/utils/collection/domain.entity.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, Domain } from '../../internal-types';
+export declare const createDomain: (value?: DeepPartial<Domain>) => Domain;
+//# sourceMappingURL=domain.entity.d.ts.map

package/dist/utils/collection/term.entity.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, Term } from '../../internal-types';
+export declare const createTerm: (value?: DeepPartial<Term>) => Term;
+//# sourceMappingURL=term.entity.d.ts.map

package/dist/utils/collection/word.entity.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, Word } from '../../internal-types';
+export declare const createWord: (value?: DeepPartial<Word>) => Word;
+//# sourceMappingURL=word.entity.d.ts.map

package/dist/utils/dictionary-csv/csv.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reads CSV text as RFC 4180 writes it: a quoted field holds commas, line
+ * breaks and doubled quotes. A record ends at CRLF, LF or CR, a blank line is
+ * no record, and a stray quote stays as text, so no input throws.
+ */
+export declare function parseCsv(text: string): string[][];
+/**
+ * Writes records as CSV text a spreadsheet opens as UTF-8: a byte order mark
+ * first and CRLF after every record. Only a field holding a quote, a comma or
+ * a line break is quoted, its quotes doubled.
+ */
+export declare function serializeCsv(records: ReadonlyArray<ReadonlyArray<string>>): string;
+//# sourceMappingURL=csv.d.ts.map

package/dist/utils/dictionary-csv/decode.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reads a file's bytes as UTF-8 with its byte order mark dropped, or as EUC-KR
+ * when they are no valid UTF-8, as an older public-standard file is. Bytes
+ * neither reads come out as replacement characters, which no header matches.
+ */
+export declare function decodeCsvBytes(bytes: ArrayBuffer | Uint8Array): string;
+//# sourceMappingURL=decode.d.ts.map

package/dist/utils/dictionary-csv/dictionaryCsv.d.ts

@@ -0,0 +1,55 @@
+import { DictionaryKind } from '../../engine/modules/dictionary/actions';
+import { Domain, Term, ValuesType, Word } from '../../internal-types';
+/** The two layouts a dictionary file comes in: the editor's own and the public standard's. */
+export declare const DictionaryCsvFormat: {
+    readonly own: "own";
+    readonly publicStandard: "publicStandard";
+};
+export type DictionaryCsvFormat = ValuesType<typeof DictionaryCsvFormat>;
+/** What a file's row of each dictionary holds; a term names its domain by the domain's name. */
+export type DictionaryCsvValues = {
+    [DictionaryKind.word]: Omit<Word, 'id' | 'order'>;
+    [DictionaryKind.term]: Omit<Term, 'id' | 'domainId' | 'order'> & {
+        domain: string;
+    };
+    [DictionaryKind.domain]: Omit<Domain, 'id' | 'order'>;
+};
+export type DictionaryCsvField<K extends DictionaryKind> = Extract<keyof DictionaryCsvValues[K], string>;
+/**
+ * The columns of the editor's own format, in the order an export writes them,
+ * each headed by its field's name. No id rides, since every document mints its
+ * own, so a file carries into another document whole.
+ */
+export declare const DictionaryCsvColumns: {
+    readonly [K in DictionaryKind]: ReadonlyArray<DictionaryCsvField<K>>;
+};
+/** A row a file brings: its name, and each other field the file has a column for. */
+export type DictionaryCsvRow<K extends DictionaryKind> = {
+    name: string;
+} & Partial<DictionaryCsvValues[K]>;
+/** A dictionary file as read: its kind and format, told by its header, and its rows in file order. */
+export type DictionaryCsvRead = {
+    [K in DictionaryKind]: {
+        kind: K;
+        format: DictionaryCsvFormat;
+        /** The fields the file has columns for, the name first, in the own format's order. */
+        fields: Array<DictionaryCsvField<K>>;
+        /** Every row with a name, each holding exactly the fields above. */
+        rows: Array<DictionaryCsvRow<K>>;
+        /** The rows left out for an empty name; a record of empty cells is no row at all. */
+        skipped: number;
+    };
+}[DictionaryKind];
+/**
+ * Reads a dictionary file's text by the one layout its header names, else null.
+ * The own format's cells stay as written, so an export reads back to its rows;
+ * the public standard's are trimmed, and a domain's type columns join in one.
+ */
+export declare function readDictionaryCsv(text: string): DictionaryCsvRead | null;
+/**
+ * Writes one dictionary's rows in the editor's own format: the field names as
+ * the header over one record per row, in the order given. A term's row names
+ * its domain, which the caller looks up by the term's domain id.
+ */
+export declare function writeDictionaryCsv<K extends DictionaryKind>(kind: K, rows: ReadonlyArray<DictionaryCsvValues[K]>): string;
+//# sourceMappingURL=dictionaryCsv.d.ts.map

package/dist/utils/dictionary-csv/index.d.ts

@@ -0,0 +1,4 @@
+export * from './csv';
+export * from './decode';
+export * from './dictionaryCsv';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/diff/compareEntities.d.ts

@@ -0,0 +1,39 @@
+import { RootState } from '../../engine/state';
+import { Column, Index, Memo, Relationship, Table, TableGroup } from '../../internal-types';
+import { Pairing } from './pairEntities';
+import { DiffChange } from './types';
+/** Both documents and what pairs across them, which every comparison reads. */
+export type DiffContext = {
+    prev: RootState;
+    next: RootState;
+    tables: Pairing;
+    columns: Pairing;
+    tableGroups: Pairing;
+};
+/** Name, comment, the group it is in, where it stands and its colour; never its z-index or the widths its text gives it. */
+export declare function compareTables(ctx: DiffContext, prev: Table, next: Table): DiffChange[];
+/**
+ * Name, comment, type, default and the four options, and its place among the
+ * columns once it moved, given as where it stood and stands, counted from one.
+ */
+export declare function compareColumns(prev: Column, next: Column, moved: {
+    before: number;
+    after: number;
+} | null): DiffChange[];
+/** The columns of an index in key order, each as the current column it pairs with and its direction. */
+export declare function indexKeyOf(ctx: DiffContext, index: Index, side: 'prev' | 'next'): string;
+/** Name, UNIQUE, and the columns in their order and direction, each column by the one it pairs with. */
+export declare function compareIndexes(ctx: DiffContext, prev: Index, next: Index): DiffChange[];
+/** A foreign key as it reads: its columns, the parent and the parent's columns. */
+export declare function foreignKeyText(state: RootState, relationship: Relationship): string;
+/** The column pairs of a foreign key, child to parent, as the current columns they pair with. */
+export declare function foreignKeyPairsOf(ctx: DiffContext, relationship: Relationship, side: 'prev' | 'next'): string;
+/** Its column pairs, its kind and what ON DELETE and ON UPDATE do; never where its ends are anchored. */
+export declare function compareForeignKeys(ctx: DiffContext, prev: Relationship, next: Relationship): DiffChange[];
+/** What it says, where it stands, its size and its colour; never its z-index. */
+export declare function compareMemos(prev: Memo, next: Memo): DiffChange[];
+/** The tables a group holds, each as the current table it pairs with. */
+export declare function groupMembersOf(ctx: DiffContext, group: TableGroup, side: 'prev' | 'next'): string[];
+/** Name, the tables it holds, its colour and the box it keeps; never its z-index. */
+export declare function compareTableGroups(ctx: DiffContext, prev: TableGroup, next: TableGroup): DiffChange[];
+//# sourceMappingURL=compareEntities.d.ts.map

package/dist/utils/diff/diffDocuments.d.ts

@@ -0,0 +1,12 @@
+import { RootState } from '../../engine/state';
+import { DocumentDiff } from './types';
+/**
+ * What changed from a saved document to the current one: the entries the diff
+ * tree lists and the marks each pane draws, which say the same thing. An entity
+ * pairs by id, then one to one by a name it keeps (src/components/erd/AGENTS.md).
+ *
+ * @example
+ * const { entries, prev, next } = diffDocuments(savedStore.state, store.state);
+ */
+export declare function diffDocuments(prev: RootState, next: RootState): DocumentDiff;
+//# sourceMappingURL=diffDocuments.d.ts.map

package/dist/utils/diff/index.d.ts

@@ -0,0 +1,5 @@
+export * from './compareEntities';
+export * from './diffDocuments';
+export * from './pairEntities';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/diff/pairEntities.d.ts

@@ -0,0 +1,41 @@
+/** Which entity of the saved document stands for which of the current one, both ways. */
+export type Pairing = {
+    /** A saved id to the current id it pairs with. */
+    toNext: Map<string, string>;
+    /** A current id to the saved id it pairs with. */
+    toPrev: Map<string, string>;
+};
+export declare const emptyPairing: () => Pairing;
+/** An id as the current one it stands for: a saved id as the one it pairs with, or one no current id can equal. */
+export declare function asNextId(pairing: Pairing, id: string, side: 'prev' | 'next'): string;
+/**
+ * A key two entities pair on, read on either side: a saved entity spells the
+ * ids it refers to as the current ones they pair with, so equal keys mean the
+ * same thing. Null for an entity the key cannot pair, an unnamed one say.
+ */
+export type PairKey<T> = (item: T, side: 'prev' | 'next') => string | null;
+/**
+ * Pairs two lists one to one: by id first, then by each key in turn, the
+ * saved entities taken in document order each pairing with the first current
+ * one left that has its key, so a rerun pairs the same way.
+ *
+ * @example
+ * pairEntities(prevTables, nextTables, [table => table.name.trim() ? table.name : null]);
+ */
+export declare function pairEntities<T extends {
+    id: string;
+}>(prev: ReadonlyArray<T>, next: ReadonlyArray<T>, keys?: ReadonlyArray<PairKey<T>>): Pairing;
+/**
+ * Pairs what is left by the most members two entities share, for those a key
+ * cannot name, such as table groups with no name: the saved ones in document
+ * order, each taking the current one it shares the most with, ties the first.
+ */
+export declare function pairByOverlap<T extends {
+    id: string;
+}>(pairing: Pairing, prev: ReadonlyArray<T>, next: ReadonlyArray<T>, membersOf: (item: T, side: 'prev' | 'next') => ReadonlyArray<string>): void;
+/**
+ * The positions of the longest run two sequences share in order, as the
+ * indexes of the second one, so an entry outside it is one that moved.
+ */
+export declare function longestCommonIndexes(a: ReadonlyArray<string>, b: ReadonlyArray<string>): Set<number>;
+//# sourceMappingURL=pairEntities.d.ts.map

package/dist/utils/diff/types.d.ts

@@ -0,0 +1,81 @@
+import { DiffMap } from '../../components/erd/diff-viewer/diff';
+import { ValuesType } from '../../internal-types';
+export declare const DiffKind: {
+    readonly table: "table";
+    readonly column: "column";
+    readonly index: "index";
+    readonly foreignKey: "foreignKey";
+    readonly memo: "memo";
+    readonly tableGroup: "tableGroup";
+};
+export type DiffKind = ValuesType<typeof DiffKind>;
+export declare const DiffStatus: {
+    readonly added: "added";
+    readonly modified: "modified";
+    readonly deleted: "deleted";
+    readonly renamed: "renamed";
+};
+export type DiffStatus = ValuesType<typeof DiffStatus>;
+/** What of an entity changed, each the name of a tooltip line. */
+export declare const DiffField: {
+    readonly name: "name";
+    readonly comment: "comment";
+    readonly dataType: "dataType";
+    readonly default: "default";
+    readonly autoIncrement: "autoIncrement";
+    readonly primaryKey: "primaryKey";
+    readonly unique: "unique";
+    readonly notNull: "notNull";
+    readonly order: "order";
+    readonly tableGroup: "tableGroup";
+    readonly position: "position";
+    readonly size: "size";
+    readonly color: "color";
+    readonly members: "members";
+    readonly columns: "columns";
+    readonly relationshipType: "relationshipType";
+    readonly onDelete: "onDelete";
+    readonly onUpdate: "onUpdate";
+    readonly value: "value";
+};
+export type DiffField = ValuesType<typeof DiffField>;
+/** A value as the saved or the current document holds it, before any wording. */
+export type DiffValue = string | number | boolean;
+export type DiffChange = {
+    field: DiffField;
+    before: DiffValue;
+    after: DiffValue;
+};
+/**
+ * One entity the two documents differ on, or that holds one that does. Its
+ * status is null for a table listed only for what changed inside it.
+ */
+export type DiffEntry = {
+    kind: DiffKind;
+    status: DiffStatus | null;
+    prevId: string | null;
+    nextId: string | null;
+    /** What the current document calls it, or the saved one where it is gone. */
+    name: string;
+    /** What the saved document calls it, the same as name unless renamed or added. */
+    prevName: string;
+    /** A table's or column's logical name, as name is taken, which a label shows and no change counts; '' for any other. */
+    logicalName: string;
+    /** The saved document's logical name, as prevName is taken. */
+    prevLogicalName: string;
+    changes: DiffChange[];
+    /** A table's columns, indexes and foreign keys, in that order. */
+    children: DiffEntry[];
+};
+export type DiffEntries = {
+    tables: DiffEntry[];
+    tableGroups: DiffEntry[];
+    memos: DiffEntry[];
+};
+/** The entries for the tree and what each pane marks, which say the same thing. */
+export type DocumentDiff = {
+    entries: DiffEntries;
+    prev: DiffMap;
+    next: DiffMap;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/utils/emitter.d.ts

@@ -4,12 +4,6 @@ import { LocaleOption } from '../i18n/locales';
 import { ValuesType } from '../internal-types';
 import { ThemeOptions } from '../themes/radix-ui-theme';
 import { GeometrySource } from './draw-relationship/geometrySource';
-import { FindField } from './find-replace/findMatches';
-/** A search the palette hands Find and Replace: the query, and the kinds of text it searches in. */
-export type FindReplaceQuery = {
-    query: string;
-    fields: FindField[];
-};
 /**
  * What Map Columns opens on: a relationship drawn between two tables and not
  * made yet, or one the document holds whose columns it changes.
@@ -71,7 +65,7 @@ type InternalActionMap = {
         event: ClipboardEvent;
     };
     [InternalActionType.toggleSearch]: void;
-    [InternalActionType.openFindReplace]: FindReplaceQuery | void;
+    [InternalActionType.openFindReplace]: void;
     [InternalActionType.openExportImage]: void;
     [InternalActionType.openMapColumns]: MapColumnsOpening;
     [InternalActionType.openThemeBuilder]: void;
@@ -178,7 +172,7 @@ export declare const toggleSearchAction: {
     type: string;
 };
 export declare const openFindReplaceAction: {
-    (payload: void | FindReplaceQuery): AnyAction<void | FindReplaceQuery>;
+    (payload: void): AnyAction<void>;
     toString(): string;
     type: string;
 };

package/dist/utils/file/exportFile.d.ts

@@ -1,3 +1,4 @@
+import { DictionaryKind } from '../../engine/modules/dictionary/actions';
 import { DocumentPngOptions, DocumentSvgOptions } from '../../services/export-png';
 type ExportOptions = {
     fileName: string;
@@ -6,6 +7,15 @@ type ExportFileCallback = (blob: Blob, options: ExportOptions) => void;
 export declare function setExportFileCallback(callback: ExportFileCallback | null): void;
 export declare function exportJSON(json: string, name?: string): void;
 export declare function exportSchemaSQL(sql: string, name?: string): void;
+/**
+ * One dictionary's sheet as a CSV file, named as the other exports are with
+ * the sheet after the time. The text is written as given, so the byte order
+ * mark and the CRLF line ends the dictionary codec writes reach the file.
+ *
+ * @example
+ * exportCSV(writeDictionaryCsv('word', words), 'word', databaseName);
+ */
+export declare function exportCSV(csv: string, sheet: DictionaryKind, name?: string): void;
 /** The Code Generator's text, named as the other exports are, with its language's extension. */
 export declare function exportCode(code: string, extension: string, name?: string): void;
 /**

package/dist/utils/find-replace/findMatches.d.ts

@@ -8,20 +8,23 @@ export declare const FindField: {
     readonly columnName: "columnName";
     readonly columnComment: "columnComment";
     readonly memo: "memo";
+    readonly indexName: "indexName";
+    readonly tableGroupName: "tableGroupName";
+    readonly logicalName: "logicalName";
 };
 export type FindField = ValuesType<typeof FindField>;
 export declare const FindFieldList: ReadonlyArray<FindField>;
 /**
- * The kinds of text Find and Replace first opens on, the names of tables and
- * columns alone (an owner decision): a comment or memo is prose a rename
- * should not reach unasked. A search given no fields still reads every kind.
+ * The kinds of text Find and Replace first opens on, the names alone of
+ * tables, columns, indexes and table groups and the logical names (owner
+ * decisions): a comment or memo is prose a rename should not reach unasked.
  */
 export declare const DEFAULT_FIND_FIELDS: ReadonlyArray<FindField>;
 export type FindMatch = {
     field: FindField;
-    /** The entity holding the text: a table, a column or a memo. */
+    /** The entity holding the text: a table, a column, an index, a table group or a memo. */
     id: string;
-    /** The table of a table or column field; empty for a memo. */
+    /** The table of a table, column or index field; empty for a memo or a table group. */
     tableId: string;
     /** Where the field stands in the walk, so a match keeps its place when its text changes. */
     slot: number;
@@ -30,6 +33,11 @@ export type FindMatch = {
     end: number;
 };
 type Field = Omit<FindMatch, 'start' | 'end'>;
+/**
+ * Whether a logical name field is a table's, which bears its table's id as
+ * its own, rather than a column's: the one field kind both of them hold.
+ */
+export declare const isTableLogicalName: ({ field, id, tableId, }: Pick<FindMatch, "field" | "id" | "tableId">) => boolean;
 /**
  * What changes a text the search reads, or which fields it walks: the actions
  * a search on screen runs again on. A hover, a selection or a scroll changes
@@ -37,19 +45,30 @@ type Field = Omit<FindMatch, 'start' | 'end'>;
  */
 export declare const FindTextActionTypes: ReadonlyArray<ActionType>;
 /**
- * Every text field the fields given cover, in document order: each table's
- * name and comment, then its columns' names and comments, then the memos.
- * The walk reads the live id lists, since a removed entity keeps its record.
+ * The order a walk takes the tables and the table groups in. A search on the
+ * tree reads them by name; a run of Replace presses keeps the order it began
+ * with, so a rename that moves a table in the name order is not met again.
+ */
+export type FieldOrder = {
+    tableIds: ReadonlyArray<string>;
+    tableGroupIds: ReadonlyArray<string>;
+};
+/** The tables and the table groups by name, as the tree lists them, ties in document order. */
+export declare function treeOrderOf({ doc, collections }: RootState): FieldOrder;
+/**
+ * Every text field the fields given cover: each table's logical name, name
+ * and comment, its columns' alike and its index names, then the table groups'
+ * names and the memos, in document order or in the order given.
  */
-export declare function walkFields(state: RootState, fields: ReadonlyArray<FindField>): Field[];
+export declare function walkFields(state: RootState, fields: ReadonlyArray<FindField>, order?: FieldOrder): Field[];
 /**
  * Every occurrence the matcher finds in the fields given, one entry each, in
- * document order.
+ * document order or in the order given.
  *
  * @example
  * findMatches(store.state, matcher, [FindField.columnName]);
  */
-export declare function findMatches(state: RootState, matcher: Matcher, fields?: ReadonlyArray<FindField>): FindMatch[];
+export declare function findMatches(state: RootState, matcher: Matcher, fields?: ReadonlyArray<FindField>, order?: FieldOrder): FindMatch[];
 /**
  * The matches as they will stand once the field a match was found in holds a
  * new value, before the store has it: that field searched again in the value,
@@ -76,7 +95,7 @@ export type ReplaceRun = Pick<FindMatch, 'field' | 'id' | 'slot' | 'start'> & {
  * table added or removed before it moves that, or null once the field is gone
  * or holds a text the run did not leave, after an undo or a peer's edit say.
  */
-export declare function resumeRun(state: RootState, fields: ReadonlyArray<FindField>, run: ReplaceRun | null): ReplaceRun | null;
+export declare function resumeRun(state: RootState, fields: ReadonlyArray<FindField>, run: ReplaceRun | null, order?: FieldOrder): ReplaceRun | null;
 /**
  * Where a Replace goes on to once it has written value in place of a match:
  * the first match past what it wrote, wrapping to the first, or minus one once

package/dist/utils/find-replace/matcher.d.ts

@@ -2,6 +2,8 @@ export type FindOptions = {
     matchCase: boolean;
     wholeWord: boolean;
     regex: boolean;
+    /** Cases each replacement the way the text it replaces is (preserveCase.ts). */
+    preserveCase?: boolean;
 };
 export type TextRange = {
     start: number;

package/dist/utils/find-replace/present.d.ts

@@ -4,10 +4,11 @@ import { FindField, FindMatch } from './findMatches';
 /** The kind of text a match was found in, as its result row names it. */
 export declare const FindFieldLabel: Record<FindField, PlainMessageKey>;
 /**
- * Where a match sits, as a reader finds it on the canvas: the table, or the
- * table and column, and nothing for a memo, which has no name.
+ * Where a match sits, as a reader finds it on the canvas: the table, the
+ * table and column, the table an index belongs to, and nothing for a memo or
+ * a table group, which stand on their own.
  */
-export declare function locationOf({ collections }: RootState, { field, id, tableId }: FindMatch, i18n?: Pick<I18n, 't'>): string;
+export declare function locationOf({ collections }: RootState, match: FindMatch, i18n?: Pick<I18n, 't'>): string;
 /** A result row's second line: where the match sits, then the kind of text it was found in. */
 export declare function describeMatch(state: RootState, match: FindMatch, i18n?: Pick<I18n, 't'>): string;
 export type Snippet = {

package/dist/utils/find-replace/preserveCase.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The replacement cased the way the text it replaces is, as VS Code's Preserve
+ * Case does: all upper, all lower or by the first letter, and piece by piece
+ * across the hyphens or the underscores both split into as many pieces by.
+ *
+ * @example
+ * preserveCase('USER_ID', 'account_key'); // 'ACCOUNT_KEY'
+ */
+export declare function preserveCase(matched: string, replacement: string): string;
+//# sourceMappingURL=preserveCase.d.ts.map

package/dist/utils/find-replace/replaceActions.d.ts

@@ -1,15 +1,19 @@
-import { AnyAction } from '@dineug/r-html';
+import { CompositionAction } from '@dineug/r-html';
 import { FindMatch } from './findMatches';
 import { Matcher } from './matcher';
-/** The atom action that writes a new value into the field a match was found in. */
-export declare function toFieldAction({ field, id, tableId }: Pick<FindMatch, 'field' | 'id' | 'tableId'>, value: string): AnyAction;
+/**
+ * What writes a new value into the field a match was found in, as an edit by
+ * hand does: a name through the generator that turns its derived flag off, a
+ * logical name through the one that derives its name, the rest by atom action.
+ */
+export declare function toFieldAction(match: Pick<FindMatch, 'field' | 'id' | 'tableId'>, value: string): CompositionAction;
 export type ReplaceActions = {
-    actions: AnyAction[];
+    actions: CompositionAction[];
     /** The matches the replacement changed, leaving out one it wrote back as it was. */
     replaced: number;
 };
 /**
- * One atom action per field whose text the replacement changes, for a single
+ * One field action per field whose text the replacement changes, for a single
  * dispatch: one undo entry, and the same LWW writes a peer receives from an
  * edit by hand. Given one match, only that occurrence is replaced.
  *

package/dist/utils/focus.d.ts

@@ -1,6 +1,8 @@
 import { FocusTable, FocusType, SharedFocus } from '../engine/modules/editor/state';
 export declare function isFocus(focusTable: Pick<FocusTable, 'tableId' | 'columnId' | 'focusType'> | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
 export declare const isSelectColumn: (focusTable: FocusTable | null, tableId: string, columnId: string) => boolean;
+/** Whether the focus stands on any cell of this column. */
+export declare const isFocusColumn: (focusTable: Pick<FocusTable, "tableId" | "columnId"> | null, tableId: string, columnId: string) => boolean;
 export declare function isEdit(focusTable: FocusTable | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
 export declare function lastCursorFocus(input: HTMLInputElement | HTMLTextAreaElement): void;
 export declare const toSharedFocus: (focusTable: FocusTable | null) => SharedFocus | null;

package/dist/utils/formatCount.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A count shown beside a name, a Dictionary sheet's or an Explorer folder's, its
+ * thousands grouped as the language groups them, in the digits 0 to 9 every
+ * other number in the editor is written in.
+ *
+ * @example
+ * formatCount('de-DE', 13176); // '13.176'
+ */
+export declare function formatCount(locale: string, count: number): string;
+//# sourceMappingURL=formatCount.d.ts.map