@dineug/erd-editor 3.9.2 → 3.10.0

package/dist/utils/calcTable.d.ts

@@ -9,9 +9,17 @@ export declare function getWidthGeneration(): number;
  * relationship-sort hook for any action that is not a pure move.
  */
 export declare function invalidateTableWidths(): void;
-export declare function calcTableWidths(table: Table, { settings: { show, maxWidthComment }, collections }: RootState): ColumnWidth;
+/**
+ * The room a row keeps for the table's alternate key marks after its last
+ * cell: the longest mark, or none while the marks are hidden or the table has
+ * none, so only a table that shows one widens.
+ */
+export declare function calcAlternateKeyWidth(table: Table, state: RootState): number;
+export declare function calcTableWidths(table: Table, state: RootState): ColumnWidth;
 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;
     comment: number;
     dataType: number;

package/dist/utils/emitter.d.ts

@@ -3,6 +3,12 @@ import { TablePlacement } from '../constants/tablePlacement';
 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[];
+};
 declare const InternalActionType: {
     readonly openColorPicker: "openColorPicker";
     readonly closeColorPicker: "closeColorPicker";
@@ -13,6 +19,7 @@ declare const InternalActionType: {
     readonly paste: "paste";
     readonly schemaGC: "schemaGC";
     readonly toggleSearch: "toggleSearch";
+    readonly openFindReplace: "openFindReplace";
     readonly openThemeBuilder: "openThemeBuilder";
     readonly setThemeOptions: "setThemeOptions";
     readonly mouseTrackerStart: "mouseTrackerStart";
@@ -46,6 +53,7 @@ type InternalActionMap = {
     };
     [InternalActionType.schemaGC]: void;
     [InternalActionType.toggleSearch]: void;
+    [InternalActionType.openFindReplace]: FindReplaceQuery | void;
     [InternalActionType.openThemeBuilder]: void;
     [InternalActionType.setThemeOptions]: Partial<ThemeOptions>;
     [InternalActionType.mouseTrackerStart]: void;
@@ -146,6 +154,11 @@ export declare const toggleSearchAction: {
     toString(): string;
     type: string;
 };
+export declare const openFindReplaceAction: {
+    (payload: void | FindReplaceQuery): AnyAction<void | FindReplaceQuery>;
+    toString(): string;
+    type: string;
+};
 export declare const openThemeBuilderAction: {
     (payload: void): AnyAction<void>;
     toString(): string;

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

@@ -0,0 +1,90 @@
+import { ActionType } from '../../engine/actions';
+import { RootState } from '../../engine/state';
+import { ValuesType } from '../../internal-types';
+import { Matcher } from './matcher';
+export declare const FindField: {
+    readonly tableName: "tableName";
+    readonly tableComment: "tableComment";
+    readonly columnName: "columnName";
+    readonly columnComment: "columnComment";
+    readonly memo: "memo";
+};
+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.
+ */
+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. */
+    id: string;
+    /** The table of a table or column field; empty for a memo. */
+    tableId: string;
+    /** Where the field stands in the walk, so a match keeps its place when its text changes. */
+    slot: number;
+    text: string;
+    start: number;
+    end: number;
+};
+type Field = Omit<FindMatch, 'start' | 'end'>;
+/**
+ * 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
+ * none, and a slow pattern would stall the tab on every one of them.
+ */
+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.
+ */
+export declare function walkFields({ doc, collections }: RootState, fields: ReadonlyArray<FindField>): Field[];
+/**
+ * Every occurrence the matcher finds in the fields given, one entry each, in
+ * document order.
+ *
+ * @example
+ * findMatches(store.state, matcher, [FindField.columnName]);
+ */
+export declare function findMatches(state: RootState, matcher: Matcher, fields?: ReadonlyArray<FindField>): 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,
+ * every other one as it was, since no other text moves.
+ */
+export declare function rematchField(matches: ReadonlyArray<FindMatch>, matcher: Matcher, changed: FindMatch, value: string): FindMatch[];
+/**
+ * The match a search goes on to once the text before a point has been dealt
+ * with: the first one past the offset in the slot given, or in a later slot,
+ * wrapping to the first. Minus one when there is none.
+ */
+export declare function indexAfter(matches: ReadonlyArray<FindMatch>, slot: number, offset: number): number;
+/**
+ * Where a run of Replace presses began, and whether it has since gone past the
+ * last match to the first. Its field is known by entity, with the text the run
+ * left there, since a slot shifts and an undo or a peer may write over that text.
+ */
+export type ReplaceRun = Pick<FindMatch, 'field' | 'id' | 'slot' | 'start'> & {
+    text: string;
+    wrapped: boolean;
+};
+/**
+ * A run as the document stands now, its field's slot found again, since a
+ * 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;
+/**
+ * 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
+ * the run has wrapped and come back to where it began, which it would replace again.
+ */
+export declare function nextReplace(after: ReadonlyArray<FindMatch>, match: FindMatch, value: string, run: ReplaceRun | null): {
+    index: number;
+    run: ReplaceRun;
+};
+export {};
+//# sourceMappingURL=findMatches.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from './findMatches';
+export * from './matcher';
+export * from './present';
+export * from './replaceActions';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,53 @@
+export type FindOptions = {
+    matchCase: boolean;
+    wholeWord: boolean;
+    regex: boolean;
+};
+export type TextRange = {
+    start: number;
+    end: number;
+};
+export type Replaced = {
+    value: string;
+    /** The occurrences whose replacement differs from the text they matched. */
+    changed: number;
+};
+export type Matcher = {
+    /** Every occurrence in the text, in order. An empty match is never one. */
+    find: (text: string) => TextRange[];
+    /**
+     * The text with its occurrences replaced, or only the one starting at the
+     * offset given. A regular expression expands $1, $<name>, $& and $$ in the
+     * replacement; plain text is inserted as it is.
+     */
+    replace: (text: string, replacement: string, onlyAt?: number) => Replaced;
+};
+export type MatcherResult = {
+    matcher: Matcher;
+    error: null;
+} | {
+    matcher: null;
+    error: 'empty' | 'invalid';
+};
+export declare const DEFAULT_FIND_OPTIONS: FindOptions;
+/**
+ * What a replacement template becomes for one match, by the rules of
+ * String.prototype.replace, which offers no way to expand a template for a
+ * match it is handed one at a time.
+ */
+export declare function expandReplacement(template: string, match: string, captures: Array<string | undefined>, position: number, subject: string, groups?: Record<string, string | undefined>): string;
+/**
+ * A typed pattern spelled for unicode mode, read the way people type it: an
+ * escaped character other than a letter, a digit or a syntax character by its
+ * code point, and a stray ] or a brace no quantifier owns as itself.
+ */
+export declare function toUnicodeSource(source: string): string;
+/**
+ * Builds the search a find and replace runs over every field, or says why
+ * there is none: nothing to look for, or a regular expression that does not parse.
+ *
+ * @example
+ * const { matcher } = createMatcher('user', { ...DEFAULT_FIND_OPTIONS, wholeWord: true });
+ */
+export declare function createMatcher(query: string, options: FindOptions): MatcherResult;
+//# sourceMappingURL=matcher.d.ts.map

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

@@ -0,0 +1,22 @@
+import { RootState } from '../../engine/state';
+import { FindField, FindMatch } from './findMatches';
+export declare const FindFieldLabel: Record<FindField, string>;
+/**
+ * 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.
+ */
+export declare function locationOf({ collections }: RootState, { field, id, tableId }: FindMatch): 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): string;
+export type Snippet = {
+    text: string;
+    start: number;
+    end: number;
+};
+/**
+ * The part of a long text a result row has room for, on one line, with the
+ * match inside it: from the start of a word some way before it, then as much
+ * after as fits. The range given back is the match's place within the excerpt.
+ */
+export declare function snippetOf({ text, start, end }: Pick<FindMatch, 'text' | 'start' | 'end'>, before?: number, length?: number): Snippet;
+//# sourceMappingURL=present.d.ts.map

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

@@ -0,0 +1,20 @@
+import { AnyAction } 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;
+export type ReplaceActions = {
+    actions: AnyAction[];
+    /** 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
+ * 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.
+ *
+ * @example
+ * store.dispatchSync(toReplaceActions(matches, matcher, 'account_id').actions);
+ */
+export declare function toReplaceActions(matches: ReadonlyArray<FindMatch>, matcher: Matcher, replacement: string, only?: FindMatch): ReplaceActions;
+//# sourceMappingURL=replaceActions.d.ts.map

package/dist/utils/generator-code/utils.d.ts

@@ -1,5 +1,6 @@
 import { DataTypeHint, PrimitiveType } from '../../constants/sql/dataType';
-import { Column, Table } from '../../internal-types';
+import { Column, Relationship, Table } from '../../internal-types';
+import { ReferentialActionSupport } from '../schema-sql/utils';
 export interface FormatTableOptions {
     buffer: string[];
     table: Table;
@@ -17,4 +18,14 @@ export declare const hasNRelationship: (value: number) => boolean;
 export declare function getPrimitiveType(dataType: string, database: number): PrimitiveType;
 export declare function getDataTypeHints(database: number): DataTypeHint[];
 export declare function getNameCase(name: string, nameCase: number): string;
+export type ReferentialActionEntry = {
+    key: 'onDelete' | 'onUpdate';
+    action: number;
+    sql: string;
+};
+/**
+ * The actions a relationship sets, ON DELETE first, each with its SQL spelling;
+ * with a support, only those the database's DDL would write too.
+ */
+export declare function referentialActionEntries({ onDelete, onUpdate }: Pick<Relationship, 'onDelete' | 'onUpdate'>, support?: ReferentialActionSupport): ReferentialActionEntry[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/keyboard-shortcut/index.d.ts

@@ -9,6 +9,7 @@ export declare const KeyBindingName: {
     readonly edit: "edit";
     readonly stop: "stop";
     readonly search: "search";
+    readonly findReplace: "findReplace";
     readonly undo: "undo";
     readonly redo: "redo";
     readonly addTable: "addTable";
@@ -32,9 +33,15 @@ export declare const KeyBindingName: {
     readonly zenMode: "zenMode";
 };
 export type KeyBindingName = ValuesType<typeof KeyBindingName>;
-export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "primaryKey" | "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" | "findReplace" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
 export type KeyBindingMap = Record<KeyBindingName, ShortcutOption[]>;
 export declare const createKeyBindingMap: () => KeyBindingMap;
+/**
+ * Whether the press is one of the chords given, read the way tinykeys reads a
+ * binding: the key by its code or its value, every modifier named held down and
+ * no other. A sequence of presses never matches a single one.
+ */
+export declare function matchesShortcut(event: KeyboardEvent, options: ReadonlyArray<ShortcutOption>): boolean;
 export declare function shortcutToTuple(shortcut?: string): KeyBindingPress[];
 export declare function isMod(event: MouseEvent | TouchEvent | KeyboardEvent): boolean;
 /**

package/dist/utils/loadValue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The text a load parses, trimmed. An empty one, a new file's, is a document
+ * created from nothing, written out in full so every peer replaying the load
+ * reads that document, a released one included, which cannot parse nothing.
+ */
+export declare function toLoadValue(value: unknown): string;
+//# sourceMappingURL=loadValue.d.ts.map

package/dist/utils/referentialAction.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The action a source spells as SQL does, in any case, with a space or an
+ * underscore between words: CASCADE, set null, no_action. Anything else is none.
+ */
+export declare function toReferentialAction(spelling: string): number;
+type ReferentialActions = {
+    onDelete: number;
+    onUpdate: number;
+};
+/**
+ * What a connector shows at its child end: D: for ON DELETE, then U: for ON
+ * UPDATE, each only when set, so a relationship that sets neither shows none.
+ *
+ * @example
+ * referentialActionLabel({ onDelete: cascade, onUpdate: restrict }); // 'D:C U:R'
+ */
+export declare function referentialActionLabel({ onDelete, onUpdate, }: ReferentialActions): string;
+/** The clauses the label stands for, one to a line, as a hover spells them out. */
+export declare function referentialActionTitle({ onDelete, onUpdate, }: ReferentialActions): string;
+export {};
+//# sourceMappingURL=referentialAction.d.ts.map

package/dist/utils/schema-aml-parser/types.d.ts

@@ -23,6 +23,12 @@ export type AMLRelation = {
     refCardinality: AMLCardinality;
     /** -item_kind=User>; the discriminator has no editor slot and is dropped. */
     polymorphic: boolean;
+    /**
+     * A standalone rel's onDelete and onUpdate properties as written, set null
+     * say; '' otherwise, since an inline relation's properties are its attribute's.
+     */
+    onDelete: string;
+    onUpdate: string;
 };
 /**
  * One unique / unique=name / index / index=name constraint. A bare

package/dist/utils/schema-dbml-parser/types.d.ts

@@ -45,6 +45,9 @@ export type DBMLRef = {
     operator: string;
     left: DBMLEndpoint;
     right: DBMLEndpoint;
+    /** The delete and update settings as written, set null say; '' if absent. */
+    onDelete: string;
+    onUpdate: string;
 };
 export type DBMLModel = {
     tables: DBMLTable[];

package/dist/utils/schema-sql/Databricks.d.ts

@@ -2,5 +2,10 @@ import { RootState } from '../../engine/state';
 import { FormatIndexOptions, FormatTableOptions } from './utils';
 export declare function createSchema(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/**
+ * A comment per column the diagram marks unique, after the table: UNIQUE is not
+ * one of the constraints Databricks accepts, so it is reported, never dropped.
+ */
+export declare function formatUnique({ collections }: RootState, { buffer, table }: FormatTableOptions): void;
 export declare function formatIndex({ collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
 //# sourceMappingURL=Databricks.d.ts.map

package/dist/utils/schema-sql/MSSQL.d.ts

@@ -2,5 +2,10 @@ import { RootState } from '../../engine/state';
 import { FormatIndexOptions, FormatTableOptions } from './utils';
 export declare function createSchema(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/**
+ * One named constraint per column the diagram marks unique, after the table.
+ * The whole export and the per-table Schema SQL tab both write it.
+ */
+export declare function formatUnique({ settings: { bracketType }, collections }: RootState, { buffer, table }: FormatTableOptions): void;
 export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
 //# sourceMappingURL=MSSQL.d.ts.map

package/dist/utils/schema-sql/MariaDB.d.ts

@@ -2,5 +2,10 @@ import { RootState } from '../../engine/state';
 import { FormatIndexOptions, FormatTableOptions } from './utils';
 export declare function createSchema(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/**
+ * One named constraint per column the diagram marks unique, after the table.
+ * The whole export and the per-table Schema SQL tab both write it.
+ */
+export declare function formatUnique({ settings: { bracketType }, collections }: RootState, { buffer, table }: FormatTableOptions): void;
 export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
 //# sourceMappingURL=MariaDB.d.ts.map

package/dist/utils/schema-sql/MySQL.d.ts

@@ -2,5 +2,10 @@ import { RootState } from '../../engine/state';
 import { FormatIndexOptions, FormatTableOptions } from './utils';
 export declare function createSchema(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/**
+ * One named constraint per column the diagram marks unique, after the table.
+ * The whole export and the per-table Schema SQL tab both write it.
+ */
+export declare function formatUnique({ settings: { bracketType }, collections }: RootState, { buffer, table }: FormatTableOptions): void;
 export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
 //# sourceMappingURL=MySQL.d.ts.map

package/dist/utils/schema-sql/Oracle.d.ts

@@ -2,5 +2,10 @@ import { RootState } from '../../engine/state';
 import { FormatIndexOptions, FormatTableOptions } from './utils';
 export declare function createSchema(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/**
+ * One named constraint per column the diagram marks unique, after the table.
+ * The whole export and the per-table Schema SQL tab both write it.
+ */
+export declare function formatUnique({ settings: { bracketType }, collections }: RootState, { buffer, table }: FormatTableOptions): void;
 export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
 //# sourceMappingURL=Oracle.d.ts.map

package/dist/utils/schema-sql/index.d.ts

@@ -1,5 +1,10 @@
 import { RootState } from '../../engine/state';
 import { Table } from '../../internal-types';
 export declare function createSchemaSQL(state: RootState, database?: number): string;
+/**
+ * One table's DDL for the table properties Schema SQL tab: the table, the
+ * uniqueness its columns carry where the whole export writes it as its own
+ * statement, and the table's indexes.
+ */
 export declare function createSchemaSQLTable(state: RootState, table: Table): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/schema-sql/utils.d.ts

@@ -53,4 +53,23 @@ export declare function autoName<T extends {
     name: string;
 }>(list: T[], id: string, name: string, num?: number): string;
 export declare function toOrderName(orderType: number): "" | "ASC" | "DESC";
+/** The actions a vendor accepts after ON DELETE and after ON UPDATE. */
+export type ReferentialActionSupport = {
+    onDelete: ReadonlyArray<number>;
+    onUpdate: ReadonlyArray<number>;
+};
+export declare const ALL_REFERENTIAL_ACTIONS: ReferentialActionSupport;
+/** Every action but the ones a vendor refuses, on both events. */
+export declare function withoutReferentialAction(...refused: number[]): ReferentialActionSupport;
+/**
+ * The actions the DDL of a database writes, which the code generators and the
+ * relationship menu follow too; an unknown database takes every one.
+ */
+export declare function referentialActionSupport(database: number): ReferentialActionSupport;
+/**
+ * ON DELETE, then ON UPDATE, each where the relationship sets one the vendor
+ * accepts; an action it would refuse is left out, so the default applies.
+ */
+export declare function formatReferentialActions({ onDelete, onUpdate }: Pick<Relationship, 'onDelete' | 'onUpdate'>, support: ReferentialActionSupport): string[];
+export declare function toStringLiteral(value: string): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/schema-sql-parser/index.d.ts

@@ -1,4 +1,8 @@
 import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
 import { EngineContext } from '../../engine/context';
-export declare function schemaSQLParserToSchemaJson(sql: string, ctx: EngineContext, prepare?: (schema: ERDEditorSchemaV3) => ERDEditorSchemaV3): string;
+/**
+ * The SQL as a document. The document's database, when given, names the vendor
+ * to the parser: a Databricks one reads string literals by Spark's escapes.
+ */
+export declare function schemaSQLParserToSchemaJson(sql: string, ctx: EngineContext, prepare?: (schema: ERDEditorSchemaV3) => ERDEditorSchemaV3, database?: number): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/table-clipboard/payload.d.ts

@@ -58,6 +58,9 @@ export type ClipboardRelationshipPoint = {
 };
 export type ClipboardRelationship = {
     relationshipType: number;
+    /** Absent from a copy an editor made before the referential actions. */
+    onDelete?: number;
+    onUpdate?: number;
     start: ClipboardRelationshipPoint;
     end: ClipboardRelationshipPoint;
 };

package/dist/utils/tableKeys.d.ts

@@ -0,0 +1,46 @@
+import { RootState } from '../engine/state';
+import { Table } from '../internal-types';
+type KeyState = Pick<RootState, 'doc' | 'collections'>;
+export declare function invalidateTableIndexes(): void;
+/**
+ * The ids of the table's indexes in list order, from a grouping of the whole
+ * list built once per add or drop, so measuring every table reads the list once
+ * rather than once a table. An observer still re-runs on each add and drop.
+ */
+export declare function getTableIndexIds({ doc, collections }: KeyState, tableId: string): string[];
+/**
+ * A key the table's columns declare rather than an index entity: the primary
+ * key over the columns marked PK, or one column marked UQ. The name is the one
+ * the DDL gives it where a vendor writes a name.
+ */
+export type ColumnKey = {
+    id: string;
+    kind: 'primaryKey' | 'unique';
+    name: string;
+    columnIds: string[];
+};
+/** One alternate key: a unique index of the table and the columns it keys, in key order. */
+export type AlternateKey = {
+    indexId: string;
+    columnIds: string[];
+};
+/**
+ * The keys a table's columns declare, primary key first and then each unique
+ * column in column order. Only the columns edit them, so a list showing them
+ * beside the index entities shows them read only.
+ */
+export declare function getColumnKeys({ collections }: KeyState, table: Table): ColumnKey[];
+/**
+ * The table's alternate keys, AK1 first: its unique indexes over two or more
+ * of its columns, ordered by where those columns stand in the table. Neither
+ * an undo nor a peer's concurrent add reorders them, as the index list would.
+ */
+export declare function getAlternateKeys(state: KeyState, table: Table): AlternateKey[];
+/**
+ * What each column in those keys is marked with, AK1.2 for the second column
+ * of the first key; a column in several keys carries each mark, comma joined.
+ * A column in none has no entry.
+ */
+export declare function getAlternateKeyMarks(state: KeyState, table: Table): Record<string, string>;
+export {};
+//# sourceMappingURL=tableKeys.d.ts.map

package/dist/workers/elkLayout.shared-worker.js

@@ -1 +1 @@
-import*as e from"comlink";typeof document>`u`&&Reflect.set(globalThis,`document`,{});const t={force:`force`,layeredHorizontal:`layeredHorizontal`,layeredVertical:`layeredVertical`,flow:`flow`,viewLayered:`viewLayered`};t.force;function n(e){return e!==t.force}function r(e){return e===t.flow}const i={"elk.algorithm":`layered`,"elk.layered.spacing.baseValue":`40`,"elk.spacing.componentComponent":`80`,"elk.layered.spacing.edgeNodeBetweenLayers":`120`,"elk.layered.considerModelOrder.strategy":`PREFER_EDGES`,"elk.layered.crossingMinimization.forceNodeModelOrder":`true`,"elk.layered.mergeEdges":`true`,"elk.layered.nodePlacement.strategy":`INTERACTIVE`,"elk.layered.layering.strategy":`INTERACTIVE`},a={"elk.alignment":`LEFT`},o={"elk.aspectRatio":`0.5625`},s={"elk.spacing.nodeNode":`80`,"elk.separateConnectedComponents":`true`,"elk.spacing.componentComponent":`160`},c=e=>({...s,"elk.algorithm":`layered`,"elk.direction":e,"elk.layered.spacing.nodeNodeBetweenLayers":`160`,"elk.layered.cycleBreaking.strategy":`DEPTH_FIRST`});function l(e){switch(e){case t.layeredHorizontal:return c(`RIGHT`);case t.layeredVertical:return c(`DOWN`);case t.flow:return{...c(`RIGHT`),"elk.layered.nodePlacement.strategy":`SIMPLE`,"elk.layered.spacing.edgeNodeBetweenLayers":`80`};case t.viewLayered:return{...i}}}function u(e){return e===t.viewLayered?{...a}:null}const d=[...new Set(Object.values(t).filter(n).map(e=>l(e)[`elk.algorithm`]))],f=`EAST`,p=e=>`edge-${e}-source`,m=e=>`edge-${e}-target`;function h(e,t){return e.side===t.side?e.side===f?e.row-t.row:t.row-e.row:e.side===f?-1:1}function g(e){let t=new Map,n=(e,n)=>{let r=t.get(e);r?r.push(n):t.set(e,[n])};return e.forEach((e,t)=>{n(e.source,{id:p(t),row:e.sourceRow,side:f}),n(e.target,{id:m(t),row:e.targetRow,side:`WEST`})}),new Map([...t].map(([e,t])=>[e,t.sort(h).map(({id:e,side:t})=>({id:e,width:8,height:8,layoutOptions:{"elk.port.side":t}}))]))}function _({placement:e,nodes:t,edges:n}){let i=r(e)?g(n):null;return{id:`root`,layoutOptions:l(e),children:t.map(t=>v(t,e,i)),edges:n.map(({source:e,target:t},n)=>({id:`edge-${n}`,sources:[i?p(n):e],targets:[i?m(n):t]}))}}function v({id:e,width:t,height:n,x:r,y:i,children:a},s,c){if(a?.length)return{id:e,width:t,height:n,layoutOptions:{...o},children:a.map(e=>v(e,s,c))};let l={...u(s),...c?{"elk.portConstraints":`FIXED_ORDER`}:{}};return{id:e,width:t,height:n,...r===void 0?{}:{x:r},...i===void 0?{}:{y:i},...Object.keys(l).length?{layoutOptions:l}:{},...c?{ports:c.get(e)??[]}:{}}}function y(e,t,n){return e.flatMap(({id:e,x:r,y:i,children:a})=>{let o=t+(r??0),s=n+(i??0);return a?.length?y(a,o,s):[{id:e,x:o,y:s}]})}let b=null;function x(){return b??=import(`elkjs/lib/elk.bundled.js`).then(({default:e})=>new e({algorithms:d})),b}const S=new class{async ready(){return await x(),!0}async layout(e){return y((await(await x()).layout(_(e))).children??[],0,0)}};self.onconnect=t=>{let n=t.ports[0];e.expose(S,n)};
+import*as e from"comlink";typeof document>`u`&&Reflect.set(globalThis,`document`,{});const t={force:`force`,layeredHorizontal:`layeredHorizontal`,layeredVertical:`layeredVertical`,flow:`flow`,viewLayered:`viewLayered`};t.force;function n(e){return e!==t.force}function r(e){return e===t.flow}const i={"elk.algorithm":`layered`,"elk.layered.spacing.baseValue":`40`,"elk.spacing.componentComponent":`80`,"elk.layered.spacing.edgeNodeBetweenLayers":`120`,"elk.layered.considerModelOrder.strategy":`PREFER_EDGES`,"elk.layered.crossingMinimization.forceNodeModelOrder":`true`,"elk.layered.mergeEdges":`true`,"elk.layered.nodePlacement.strategy":`INTERACTIVE`,"elk.layered.layering.strategy":`INTERACTIVE`},a={"elk.alignment":`LEFT`},o={"elk.aspectRatio":`0.5625`},s={"elk.spacing.nodeNode":`80`,"elk.separateConnectedComponents":`true`,"elk.spacing.componentComponent":`160`},c=e=>({...s,"elk.algorithm":`layered`,"elk.direction":e,"elk.layered.spacing.nodeNodeBetweenLayers":`160`,"elk.layered.cycleBreaking.strategy":`DEPTH_FIRST`});function l(e){switch(e){case t.layeredHorizontal:return c(`RIGHT`);case t.layeredVertical:return c(`DOWN`);case t.flow:return{...c(`RIGHT`),"elk.layered.nodePlacement.strategy":`SIMPLE`,"elk.layered.spacing.edgeNodeBetweenLayers":`80`};case t.viewLayered:return{...i}}}function u(e){return e===t.viewLayered?{...a}:null}const d=[...new Set(Object.values(t).filter(n).map(e=>l(e)[`elk.algorithm`]))],f=`EAST`,p=e=>`edge-${e}-source`,m=e=>`edge-${e}-target`;function h(e,t){return e.side===t.side?e.side===f?e.row-t.row:t.row-e.row:e.side===f?-1:1}function g(e){let t=/* @__PURE__ */ new Map,n=(e,n)=>{let r=t.get(e);r?r.push(n):t.set(e,[n])};return e.forEach((e,t)=>{n(e.source,{id:p(t),row:e.sourceRow,side:f}),n(e.target,{id:m(t),row:e.targetRow,side:`WEST`})}),new Map([...t].map(([e,t])=>[e,t.sort(h).map(({id:e,side:t})=>({id:e,width:8,height:8,layoutOptions:{"elk.port.side":t}}))]))}function _({placement:e,nodes:t,edges:n}){let i=r(e)?g(n):null;return{id:`root`,layoutOptions:l(e),children:t.map(t=>v(t,e,i)),edges:n.map(({source:e,target:t},n)=>({id:`edge-${n}`,sources:[i?p(n):e],targets:[i?m(n):t]}))}}function v({id:e,width:t,height:n,x:r,y:i,children:a},s,c){if(a?.length)return{id:e,width:t,height:n,layoutOptions:{...o},children:a.map(e=>v(e,s,c))};let l={...u(s),...c?{"elk.portConstraints":`FIXED_ORDER`}:{}};return{id:e,width:t,height:n,...r===void 0?{}:{x:r},...i===void 0?{}:{y:i},...Object.keys(l).length?{layoutOptions:l}:{},...c?{ports:c.get(e)??[]}:{}}}function y(e,t,n){return e.flatMap(({id:e,x:r,y:i,children:a})=>{let o=t+(r??0),s=n+(i??0);return a?.length?y(a,o,s):[{id:e,x:o,y:s}]})}let b=null;function x(){return b??=import(`elkjs/lib/elk.bundled.js`).then(({default:e})=>new e({algorithms:d})),b}const S=new class{async ready(){return await x(),!0}async layout(e){return y((await(await x()).layout(_(e))).children??[],0,0)}};self.onconnect=t=>{let n=t.ports[0];e.expose(S,n)};