@dineug/erd-editor 4.0.0 → 4.1.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

@@ -74,12 +74,17 @@ 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;
     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/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,77 @@
+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;
+    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/find-replace/findMatches.d.ts

@@ -8,20 +8,22 @@ export declare const FindField: {
     readonly columnName: "columnName";
     readonly columnComment: "columnComment";
     readonly memo: "memo";
+    readonly indexName: "indexName";
+    readonly tableGroupName: "tableGroupName";
 };
 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 (an owner decision): a comment or
+ * memo is prose a rename should not reach unasked. No fields reads every kind.
  */
 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;
@@ -37,19 +39,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 declare function walkFields(state: RootState, fields: ReadonlyArray<FindField>): Field[];
+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 name and comment,
+ * its columns' names and comments 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>, 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 +89,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,8 +4,9 @@ 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;
 /** A result row's second line: where the match sits, then the kind of text it was found in. */

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/keyboard-shortcut/index.d.ts

@@ -16,6 +16,8 @@ export declare const KeyBindingName: {
     readonly addTable: "addTable";
     readonly addColumn: "addColumn";
     readonly addMemo: "addMemo";
+    readonly addTableGroup: "addTableGroup";
+    readonly groupSelectedTables: "groupSelectedTables";
     readonly removeTable: "removeTable";
     readonly removeColumn: "removeColumn";
     readonly removeSelection: "removeSelection";
@@ -35,18 +37,24 @@ export declare const KeyBindingName: {
     readonly zenMode: "zenMode";
 };
 export type KeyBindingName = ValuesType<typeof KeyBindingName>;
-export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "primaryKey" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "findReplace" | "removeSelection" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
+export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "primaryKey" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "addTableGroup" | "findReplace" | "groupSelectedTables" | "removeSelection" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
 /**
  * The chords a press inside a floating panel still carries to the editor:
  * Find and Replace's own, search, the document's undo and redo, and the zoom.
  */
 export declare const PANEL_PASSING_BINDINGS: ReadonlyArray<KeyBindingName>;
 export type KeyBindingMap = Record<KeyBindingName, ShortcutOption[]>;
+/**
+ * Whether a press inside a panel stops there: a press an IME still holds, a
+ * chord of the map outside the passing list, or a key the panel moves or
+ * presses with. A host that leaves Escape to the editor passes stop through.
+ */
+export declare function stopsAtPanel(event: KeyboardEvent, keyBindingMap: KeyBindingMap, passing?: ReadonlyArray<KeyBindingName>): boolean;
 export declare const createKeyBindingMap: () => KeyBindingMap;
 /**
  * Whether the press is one of the chords given, matched as bindKeys matches a
- * press, so a panel reads a binding as the editor root does. A sequence of
- * presses never matches a single one.
+ * press, so a panel reads a binding as the editor root does. Of a sequence it
+ * is the last press, the one that would complete it at the root.
  */
 export declare function matchesShortcut(event: KeyboardEvent, options: ReadonlyArray<ShortcutOption>): boolean;
 export declare function shortcutToTuple(shortcut?: string): KeyBindingPress[];

package/dist/utils/takeover.d.ts

@@ -0,0 +1,6 @@
+import { RootState } from '../engine/state';
+/** The overlays that take the whole canvas over, each standing a scene of its own there. */
+export declare const TAKEOVERS: ("automaticTablePlacement" | "diffViewer" | "timeTravel")[];
+/** Whether an overlay that takes the canvas over is up, which keeps Find and Replace and the Explorer shut. */
+export declare const isTakenOver: ({ editor }: RootState) => boolean;
+//# sourceMappingURL=takeover.d.ts.map

package/dist/utils/virtualRange.d.ts

@@ -0,0 +1,15 @@
+/** How many rows a virtual list draws past each edge of its view, so a short scroll finds them drawn already. */
+export declare const VIRTUAL_OVERSCAN = 8;
+/** The rows a list renders, first to last, both included; none while last is below first. */
+export type VirtualRange = {
+    first: number;
+    last: number;
+};
+/** The rows the screen shows at a scroll offset, with the overscan either side. */
+export declare function visibleRange(count: number, scrollTop: number, height: number, rowHeight: number): VirtualRange;
+/**
+ * The scroll offset nearest the one given that shows a row whole: the same
+ * while it shows, else the row's top or bottom at the edge it is past.
+ */
+export declare function offsetToShow(index: number, scrollTop: number, height: number, rowHeight: number): number;
+//# sourceMappingURL=virtualRange.d.ts.map