@dineug/erd-editor 3.10.0 → 4.1.0

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

@@ -0,0 +1,28 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { FormatTableOptions } from './utils';
+/**
+ * PHP takes declare(strict_types=1) only as the first statement, so the text
+ * opens on the tag with nothing before it, not even the blank line the other
+ * languages open with.
+ */
+export declare const PHP_HEADER: readonly string[];
+export declare const INDENT = "    ";
+export declare function createCode(state: RootState): string;
+/** One table's class under the header, which a file of its own needs. */
+export declare function createTableCode(state: RootState, table: Table): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A PostgreSQL array type, which pdo_pgsql reads as a text literal such as {1,2}. */
+export declare function isPostgresArray(dataType: string, database: number): boolean;
+/**
+ * A name PHP refuses for a class, in any letter case, gets an underscore
+ * after it, as nikic/PHP-Parser names its List_ and Match_ nodes.
+ */
+export declare function toClassName(name: string): string;
+/**
+ * A comment as a doc block, one line or several: a line comment would end at
+ * a ?> in the text and leave PHP, where a block runs on to its close, which a
+ * star and a slash in the text would write early.
+ */
+export declare function formatDocComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=php.d.ts.map

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

@@ -0,0 +1,13 @@
+import { RootState } from '../../engine/state';
+import { FormatTableOptions } from './utils';
+export declare const INDENT = "    ";
+/** Every keyword of edition 2015 to 2024 a raw identifier takes. */
+export declare const RUST_KEYWORDS: ReadonlySet<string>;
+export declare function createCode(state: RootState): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A keyword as a raw identifier, or with an underscore after it where rustc takes none. */
+export declare function toRustIdentifier(name: string): string;
+export declare function toStructName(name: string): string;
+/** A comment as line comments, its bidirectional controls written as escapes. */
+export declare function formatComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=rust.d.ts.map

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

@@ -0,0 +1,44 @@
+/** The Rust value a column's element holds, which each generator spells its own way. */
+export type RustScalar = 'bool' | 'i8' | 'i16' | 'i32' | 'i64' | 'u8' | 'u16' | 'u32' | 'u64' | 'f32' | 'f64' | 'decimal' | 'string' | 'bytes' | 'uuid' | 'json' | 'date' | 'time' | 'dateTime' | 'dateTimeUtc' | 'dateTimeOffset';
+/**
+ * Each scalar by its full path, so a struct compiles with no use statement
+ * and beside a struct of any of these last names.
+ */
+export declare const RUST_SCALAR_PATHS: Readonly<Record<RustScalar, string>>;
+export type RustColumnType = {
+    scalar: RustScalar;
+    /** The field type with one Vec a PostgreSQL array dimension, by full paths. */
+    rust: string;
+    /**
+     * The element's type name, lower case, its arguments gone, and on MySQL and
+     * MariaDB its UNSIGNED and ZEROFILL too.
+     */
+    base: string;
+    /** The element's arguments when all are numbers: numeric(10,2) gives [10, 2]. */
+    args: number[];
+    arrayDepth: number;
+    /** MySQL and MariaDB: UNSIGNED, ZEROFILL or SERIAL in the type. */
+    isUnsigned: boolean;
+    isFloat: boolean;
+    /**
+     * PostgreSQL alone: the type sqlx reads the column through, cast, where it
+     * reads the column's own type into no Rust type here; null elsewhere.
+     */
+    selectAs: string | null;
+    /**
+     * The element as an entity declares it: a PostgreSQL array of more than one
+     * dimension, which neither sqlx nor SeaORM decodes, is a string read as text.
+     */
+    entityScalar: RustScalar;
+};
+/** PostgreSQL's character types, which sqlx reads into a String as they are. */
+export declare const POSTGRES_CHARACTER_TYPES: ReadonlySet<string>;
+/**
+ * The shared column classifier with the choices sqlx makes for Rust on top: an
+ * Oracle, Snowflake or SQLite integer keeps the width its name declares, and a
+ * MySQL SIGNED stays in the name, which keeps it from every rule by name.
+ */
+export declare function getRustColumnType(dataType: string, database: number): RustColumnType;
+/** A type inside one Vec per dimension. */
+export declare function wrapVec(type: string, depth: number): string;
+//# sourceMappingURL=rustTypes.d.ts.map

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

@@ -2,4 +2,5 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+export declare function toScalaName(name: string): string;
 //# sourceMappingURL=scala.d.ts.map

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

@@ -0,0 +1,22 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+type EntityColumnType = {
+    type: string;
+    columnType: string | null;
+    selectAs: string | null;
+    saveAs: string | null;
+    isFloat: boolean;
+};
+export declare function createCode(state: RootState): string;
+/** One table's entity as its module file holds it, named in the whole document. */
+export declare function createTableCode(state: RootState, table: Table): string;
+/** The column name DeriveEntityModel gives a field it reads without column_name. */
+export declare function derivedColumnName(field: string): string;
+/** UpperCamelCase applied until it stops changing: aBC gives ABc, then ABc. */
+export declare function stableUpperCamelCase(value: string): string;
+/** A Rust string literal rustc takes for any text. */
+export declare function rustString(value: string): string;
+/** The field type, column_type, select_as and save_as an entity writes. */
+export declare function getEntityColumnType(dataType: string, database: number): EntityColumnType;
+export {};
+//# sourceMappingURL=seaorm.d.ts.map

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

@@ -0,0 +1,44 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { FormatTableOptions } from './utils';
+/**
+ * Date, Data, Decimal and UUID need Foundation, and an unused import draws no
+ * warning, so the text and the one-table view open on it whatever they hold.
+ */
+export declare const SWIFT_HEADER: readonly string[];
+export declare const INDENT = "    ";
+/**
+ * A nonisolated struct keeps its conformances usable off the main actor in a
+ * module whose default isolation is MainActor, as new Xcode app targets set.
+ */
+export declare const STRUCT_HEAD = "nonisolated struct";
+export declare const CONFORMANCES = "Codable, Hashable, Sendable";
+/** The words the Swift lexer reserves, which a name takes only in backticks. */
+export declare const SWIFT_KEYWORDS: ReadonlySet<string>;
+/**
+ * The types and protocols the output writes unqualified: a struct of one of
+ * these names breaks the conformances or silently retypes every such field.
+ */
+export declare const TYPE_NAMES: ReadonlySet<string>;
+export declare function createCode(state: RootState): string;
+/** One table's struct under the import, which a file of its own needs. */
+export declare function createTableCode(state: RootState, table: Table): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A column's Swift type, one array a PostgreSQL dimension, without its optional. */
+export declare function swiftType(dataType: string, database: number): string;
+/** A type name gets an underscore after it, and a keyword backticks. */
+export declare function toStructName(name: string): string;
+/** A property's coding key, an underscore after a name the keys reserve. */
+export declare function toPropertyKey(name: string): string;
+export declare function toPropertyName(key: string): string;
+/**
+ * A Swift string literal: a quote and a backslash, which would also open an
+ * interpolation, get a backslash, and every C0 control and DEL an escape.
+ */
+export declare function toStringLiteral(value: string): string;
+/**
+ * A comment as documentation lines, split at every line terminator, since a
+ * lone CR ends a line comment; a NUL, which Swift warns about, is an escape.
+ */
+export declare function formatComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=swift.d.ts.map

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

@@ -15,7 +15,26 @@ export interface FormatRelationOptions {
 }
 export declare const hasOneRelationship: (value: number) => boolean;
 export declare const hasNRelationship: (value: number) => boolean;
+/** The ECMAScript line terminators, CR LF one of them, where a line comment ends. */
+export declare const LINE_TERMINATOR: RegExp;
 export declare function getPrimitiveType(dataType: string, database: number): PrimitiveType;
+/** The vendor list entry a data type names, the longest that prefixes it. */
+export declare function findDataTypeHint(dataType: string, database: number): DataTypeHint | undefined;
+/**
+ * The precision and scale of an Oracle or Snowflake NUMBER with a scale, which
+ * the vendor lists file under long with every other NUMBER; a star is 38.
+ */
+export declare function fractionalNumber(dataType: string, database: number): [precision: number, scale: number] | null;
+/** The type name in lower case, with its argument lists and extra spaces gone. */
+export declare function baseTypeName(dataType: string): string;
+/** A text split into its lines at every ECMAScript line terminator. */
+export declare function splitLines(value: string): string[];
+/**
+ * A line comment's text with a backslash before its at sign where it opens with
+ * one and ts-, after any white space and in any case, so the line stays legible
+ * and TypeScript reads no directive in it, which would hide or expect an error.
+ */
+export declare function escapeTypeScriptDirective(line: string): string;
 export declare function getDataTypeHints(database: number): DataTypeHint[];
 export declare function getNameCase(name: string, nameCase: number): string;
 export type ReferentialActionEntry = {

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

@@ -0,0 +1,25 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { JsonShape } from './jsonShape';
+import { FormatTableOptions } from './utils';
+/** Every table's row schema and its inferred type, under one import line. */
+export declare function createCode(state: RootState): string;
+/** One table under the import line, so its file compiles on its own. */
+export declare function createTableCode(state: RootState, table: Table): string;
+export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+/** A value's Zod schema, one z.array around it for each array dimension. */
+export declare function toZodSchema(shape: JsonShape): string;
+/**
+ * A name a type alias may not take, z included, gets an underscore after it;
+ * any other name, one that is no identifier or a repeated one included, is
+ * written as is.
+ */
+export declare function toZodTypeName(name: string): string;
+/**
+ * A property key as an object literal writes it; __proto__ is computed, since
+ * written plainly or quoted it would set the object's prototype instead.
+ */
+export declare function toZodPropertyKey(name: string): string;
+/** A comment as line comments, one for each of its lines, none a TypeScript directive. */
+export declare function formatComment(buffer: string[], indent: string, comment: string): void;
+//# sourceMappingURL=zod.d.ts.map

package/dist/utils/globalEventObservable.d.ts

@@ -11,12 +11,21 @@ export declare const animationFrames$: Observable<{
     elapsed: number;
 }>;
 export declare const moveStart$: Observable<MouseEvent | TouchEvent>;
+/**
+ * The middle presses a scene pan stopped below a target, read off the forward
+ * each one hands the move stream: a listener above the stage container that
+ * closes on any press hears a middle press there only this way.
+ *
+ * @example
+ * addUnsubscribe(middlePanPress$(root).subscribe(handleOutsidePress));
+ */
+export declare function middlePanPress$(target: EventTarget): Observable<MouseEvent>;
 /**
  * A gesture also ends wherever the browser takes the pointer away: a native
  * drag swallows the rest of the stream, a cancelled pointer never lifts, and a
  * blurred window never sees the mouseup, each leaving drag$ subscribed.
  */
-export declare const moveEnd$: Observable<MouseEvent | TouchEvent | DragEvent | PointerEvent | FocusEvent>;
+export declare const moveEnd$: Observable<MouseEvent | TouchEvent | FocusEvent | PointerEvent | DragEvent>;
 export type DragMove = {
     movementX: number;
     movementY: number;

package/dist/utils/highlightWords.d.ts

@@ -0,0 +1,29 @@
+import { TextRange } from './find-replace';
+/** A stretch of the text, lit or plain; the chunks of one text run end to end. */
+type Chunk = TextRange & {
+    highlight: boolean;
+};
+export type FindChunksArgs = {
+    searchWords: string[];
+    textToHighlight: string;
+    /** Whether a word lights only its own letter case; false when left out. */
+    caseSensitive?: boolean;
+};
+export type FindAllArgs = FindChunksArgs & {
+    /** Where the text holds the words, findChunks when left out; the ranges may overlap and come in any order. */
+    findChunks?: (args: FindChunksArgs) => TextRange[];
+};
+/**
+ * Where the text holds each word, word by word and left to right, a match
+ * starting only past the end of that word's last one: a word is read as typed,
+ * never as a regular expression, and an empty one holds nothing.
+ */
+export declare function findChunks({ searchWords, textToHighlight, caseSensitive, }: FindChunksArgs): TextRange[];
+/**
+ * The whole text as chunks: one lit chunk for each run of matches that overlap
+ * or touch, so two words side by side light as one, and plain chunks between
+ * them. An empty text has none.
+ */
+export declare function findAll({ searchWords, textToHighlight, caseSensitive, findChunks: find, }: FindAllArgs): Chunk[];
+export {};
+//# sourceMappingURL=highlightWords.d.ts.map

package/dist/utils/index.d.ts

@@ -1,8 +1,7 @@
-import { EntityMeta, Memo, Point, Settings, Table } from '../internal-types';
+import { Memo, Point, Settings, Table } from '../internal-types';
 export declare const nextZIndex: (tables: Table[], memos: Memo[]) => number;
 export declare function nextPoint(settings: Settings, tables: Table[], memos: Memo[]): Point;
 export declare const toList: <T>(ids: string[], entities: Record<string, T>) => Array<T>;
-export declare function getDefaultEntityMeta(): EntityMeta;
 export declare function safeRange(a: number, b: number): number[];
 export declare function pascalCase(value?: string): string;
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,9 @@
+/** A handler per shortcut, whose presses of a sequence a space separates. */
+export type KeyBindingHandlers = Record<string, (event: KeyboardEvent) => void>;
+/**
+ * Calls each shortcut's handler on the target's keydown that completes it and
+ * returns the unbinding. A modifier's own keydown keeps a sequence going; any
+ * other miss, or a second with no keydown, sends it back to its first press.
+ */
+export declare function bindKeys(target: EventTarget, handlers: KeyBindingHandlers): () => void;
+//# sourceMappingURL=bindKeys.d.ts.map

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

@@ -1,5 +1,6 @@
 import { ValuesType } from '../../internal-types';
 import { KeyBindingPress } from './utils';
+export { bindKeys, type KeyBindingHandlers } from './bindKeys';
 export type ShortcutOption = {
     shortcut: string;
     preventDefault?: boolean;
@@ -15,8 +16,11 @@ 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";
     readonly primaryKey: "primaryKey";
     readonly selectAllTable: "selectAllTable";
     readonly selectAllColumn: "selectAllColumn";
@@ -33,13 +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" | "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, 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.
+ * 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. 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/keyboard-shortcut/utils.d.ts

@@ -1,3 +1,24 @@
+import { ValuesType } from '../../internal-types';
 export type KeyBindingPress = [string[], string];
+/** The modifiers that change what a press means; AltGraph is read through them. */
+export declare const ModifierKey: {
+    readonly Shift: "Shift";
+    readonly Meta: "Meta";
+    readonly Alt: "Alt";
+    readonly Control: "Control";
+};
+export type ModifierKey = ValuesType<typeof ModifierKey>;
 export declare function parseKeybinding(str: string): KeyBindingPress[];
+/**
+ * Whether the modifier is held, AltGraph counting as the ones it aliases. A
+ * keydown Chrome sends for a function key may lack getModifierState, and then
+ * holds nothing.
+ */
+export declare function isModifierHeld(event: KeyboardEvent, mod: string): boolean;
+/**
+ * Whether the event is the press: the key by its value in any case or by its
+ * code, every modifier the press names held, and no other modifier unless it
+ * is the key itself.
+ */
+export declare function matchesPress(event: KeyboardEvent, [mods, key]: KeyBindingPress): boolean;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/map-columns/alignTypes.d.ts

@@ -0,0 +1,37 @@
+import { AnyAction } from '@dineug/r-html';
+import { RootState } from '../../engine/state';
+import { Column } from '../../internal-types';
+type AlignEnd = {
+    tableId: string;
+    columnIds: string[];
+};
+export type AlignTypesInput = {
+    /** The relationship whose columns change; a new one has none. */
+    relationshipId?: string;
+    start: AlignEnd;
+    end: AlignEnd;
+    /** The child columns the same batch adds, which already take the parent's type. */
+    newColumnIds: string[];
+};
+/**
+ * The data type changes that bring each existing child column of the mapping
+ * to its parent's, through the data type sync over the relationships as they
+ * will stand, while the sync is on; a column already at its value takes none.
+ */
+export declare function toAlignTypeActions(state: RootState, { relationshipId, start, end, newColumnIds }: AlignTypesInput): AnyAction[];
+/**
+ * What the dialog says under a row whose child column type differs from the
+ * one its parent's gives a foreign key: the type confirming writes there while
+ * the sync is on and the parent has one, else both types.
+ */
+export type TypeNote = {
+    kind: 'becomes';
+    dataType: string;
+} | {
+    kind: 'differ';
+    parentType: string;
+    childType: string;
+};
+export declare function getTypeNote({ settings: { relationshipDataTypeSync, database }, }: Pick<RootState, 'settings'>, parent: Column, child: Column): TypeNote | null;
+export {};
+//# sourceMappingURL=alignTypes.d.ts.map

package/dist/utils/map-columns/buildRows.d.ts

@@ -0,0 +1,102 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { CandidateKey } from './candidateKeys';
+import { ColumnPick, MapColumnsDraft, MappingRow } from './mapping';
+import { MappingIssues } from './validate';
+/** The child column picked for each parent column, null where the reader emptied it. */
+export type MapColumnsPicks = Readonly<Record<string, ColumnPick | null>>;
+/** A Map Columns dialog opened while drawing a relationship between two tables. */
+export type CreateMapColumnsSession = {
+    mode: 'create';
+    startTableId: string;
+    endTableId: string;
+    relationshipType: number;
+    keyId: string | null;
+    picks: MapColumnsPicks;
+};
+/** The mapping and the keys a relationship had when the dialog opened on it. */
+export type MapColumnsBase = {
+    startColumnIds: string[];
+    endColumnIds: string[];
+    keyId: string;
+    keys: Readonly<Record<string, string[]>>;
+};
+/**
+ * A Map Columns dialog opened on a relationship. Until the reader changes a row
+ * or the key it follows the relationship as it stands; after, it keeps the key
+ * and the rows they changed, the others still following it.
+ */
+export type EditMapColumnsSession = {
+    mode: 'edit';
+    relationshipId: string;
+    base: MapColumnsBase;
+    touched: boolean;
+    keyId: string;
+    picks: MapColumnsPicks;
+};
+export type MapColumnsSession = CreateMapColumnsSession | EditMapColumnsSession;
+/**
+ * A row as the dialog shows it: whether its parent or picked child column has
+ * left its table, and the name a new foreign key column takes for it beside
+ * the other rows picking one.
+ */
+export type MappingRowView = MappingRow & {
+    removedParent: boolean;
+    removedChild: boolean;
+    newColumnName: string;
+};
+/** The line under a stored mapping no key covers, or one only a key can mend. */
+export type MapColumnsNotice = 'notAKey' | 'noKey' | 'fixMapping' | 'addKeyToFix';
+/** Why the dialog closes on its own: a table it maps between, or the relationship, is gone. */
+export type MapColumnsClosed = {
+    reason: 'tableRemoved';
+    tableId: string;
+} | {
+    reason: 'relationshipRemoved';
+};
+export type MapColumnsView = {
+    closed: null;
+    parentTable: Table;
+    childTable: Table;
+    relationshipType: number;
+    keys: CandidateKey[];
+    keyId: string | null;
+    showReferences: boolean;
+    rows: MappingRowView[];
+    notice: MapColumnsNotice | null;
+    changedRemotely: boolean;
+    draft: MapColumnsDraft;
+    issues: MappingIssues;
+    canConfirm: boolean;
+};
+export type MapColumnsClosedView = {
+    closed: MapColumnsClosed;
+};
+type MapState = Pick<RootState, 'doc' | 'collections' | 'settings'>;
+/**
+ * What the dialog shows for its session over the state as it stands, built
+ * again on every render, or why it closes: a table it maps between, or the
+ * relationship it edits, has left the document.
+ */
+export declare function buildMapColumns(state: MapState, session: MapColumnsSession): MapColumnsView | MapColumnsClosedView;
+/**
+ * A dialog opened to map the start table's key onto the end table's columns:
+ * on the primary key, or the first unique column without one, each row a
+ * column of the end table only one name match points at, or empty.
+ */
+export declare function openCreateSession(state: MapState, { startTableId, endTableId, relationshipType, }: Pick<CreateMapColumnsSession, 'startTableId' | 'endTableId' | 'relationshipType'>): CreateMapColumnsSession;
+/** A dialog opened on the relationship, remembering its mapping and the parent's keys. */
+export declare function openEditSession(state: MapState, relationshipId: string): EditMapColumnsSession;
+/**
+ * The session once the reader picks another key in References: a row for each
+ * of its columns keeps the child it had where that child is live, and an empty
+ * row takes the one column a name match points at, if any.
+ */
+export declare const changeMapColumnsKey: <S extends MapColumnsSession>(state: MapState, session: S, keyId: string) => S;
+/**
+ * The session once the reader picks a child column for a row, or empties it,
+ * on the key the dialog shows, which an edit keeps from then on.
+ */
+export declare const pickMapColumn: <S extends MapColumnsSession>(state: MapState, session: S, parentColumnId: string, pick: ColumnPick | null) => S;
+export {};
+//# sourceMappingURL=buildRows.d.ts.map

package/dist/utils/map-columns/candidateKeys.d.ts

@@ -0,0 +1,24 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { ColumnKey } from '../tableKeys';
+/** The References choice that keeps a stored mapping no key of the parent covers. */
+export declare const CURRENT_KEY_ID = "current";
+/** A key a mapping can reference, or the stored columns kept as they are. */
+export type CandidateKey = {
+    id: string;
+    kind: ColumnKey['kind'] | 'current';
+    columnIds: string[];
+};
+type KeyState = Pick<RootState, 'collections' | 'settings'>;
+/**
+ * The keys a foreign key can reference on the table: its primary key, in
+ * column order, then each unique column; a unique column over the very columns
+ * of a key before it is left out, so a primary key also marked unique is one.
+ */
+export declare function getCandidateKeys(state: KeyState, table: Table): CandidateKey[];
+/** The key the table's columns declare under the id, as they declare it now. */
+export declare const findColumnKey: (state: KeyState, table: Table, keyId: string) => ColumnKey | undefined;
+/** The References choice of a stored mapping no key covers. */
+export declare const toCurrentKey: (columnIds: string[]) => CandidateKey;
+export {};
+//# sourceMappingURL=candidateKeys.d.ts.map

package/dist/utils/map-columns/index.d.ts

@@ -0,0 +1,8 @@
+export * from './alignTypes';
+export * from './buildRows';
+export * from './candidateKeys';
+export * from './mapping';
+export * from './prefill';
+export * from './toMapColumnsActions';
+export * from './validate';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/map-columns/mapping.d.ts

@@ -0,0 +1,67 @@
+import { RootState } from '../../engine/state';
+import { Relationship, Table } from '../../internal-types';
+/** The child column a row maps its parent column to: one the child holds, or a new one. */
+export type ColumnPick = {
+    kind: 'existing';
+    columnId: string;
+} | {
+    kind: 'new';
+};
+/**
+ * One pair of a mapping, a parent key column and the child column picked for
+ * it, null until one is. A place of a stored mapping its lists cannot pair is
+ * invalid, with no parent column where the start list ends before it.
+ */
+export type MappingRow = {
+    parentColumnId: string | null;
+    pick: ColumnPick | null;
+    invalid?: boolean;
+};
+/**
+ * What the Map Columns dialog confirms: the relationship to create between two
+ * tables, or the one whose columns it changes, with the parent key it reads,
+ * a key id of the parent's columns or the stored mapping kept as it is.
+ */
+export type MapColumnsDraft = {
+    mode: 'create';
+    startTableId: string;
+    endTableId: string;
+    relationshipType: number;
+    keyId: string | null;
+    rows: MappingRow[];
+} | {
+    mode: 'edit';
+    relationshipId: string;
+    keyId: string;
+    rows: MappingRow[];
+};
+/** A relationship's two column lists, end[i] referencing start[i]. */
+export type ColumnMapping = {
+    start: string[];
+    end: string[];
+};
+/** The two column lists the relationship holds, as they stand. */
+export declare const toColumnMapping: ({ start, end, }: Relationship) => ColumnMapping;
+/** The table, while the document holds it; a removed one stays an entity a while. */
+export declare function getLiveTable({ doc, collections }: Pick<RootState, 'doc' | 'collections'>, tableId: string): Table | undefined;
+/** The relationship, while the document holds it. */
+export declare function getLiveRelationship({ doc, collections }: Pick<RootState, 'doc' | 'collections'>, relationshipId: string): Relationship | undefined;
+/** Whether the column is one of the live table's, not one removed from it. */
+export declare const isLiveColumn: (table: Table | undefined, columnId: string) => boolean;
+/** Two lists holding the same ids, however ordered or repeated. */
+export declare function sameSet(a: string[], b: string[]): boolean;
+/** Two lists holding the same ids once each, however ordered. */
+export declare const sameMembers: (a: string[], b: string[]) => boolean;
+/** The ids a list holds more than once. */
+export declare function repeatedIds(ids: string[]): Set<string>;
+/** Lists of one length that repeat no id, which pair by place into one key reference. */
+export declare const isNormalMapping: ({ start, end }: ColumnMapping) => boolean;
+/** Two mappings pairing the same columns, in whatever order they list the pairs. */
+export declare const samePairs: (a: ColumnMapping, b: ColumnMapping) => boolean;
+/** Whether the relationship's own lists are normal and pair what the mapping pairs. */
+export declare function holdsPairs(relationship: Relationship, mapping: ColumnMapping): boolean;
+/** The child column each picked row maps to, in row order. */
+export declare const toPickedColumnIds: (rows: MappingRow[]) => string[];
+/** The child columns the other rows hold, which a row's own list shows in use. */
+export declare const getUsedColumnIds: (rows: MappingRow[], rowIndex: number) => Set<string>;
+//# sourceMappingURL=mapping.d.ts.map

package/dist/utils/map-columns/prefill.d.ts

@@ -0,0 +1,26 @@
+import { RootState } from '../../engine/state';
+import { Table } from '../../internal-types';
+import { CandidateKey } from './candidateKeys';
+import { ColumnPick } from './mapping';
+/**
+ * The names a child column may hold to reference the parent column, compared
+ * without case: the name a new foreign key column would take, that name from
+ * the table name without its schema, and for a unique key the column's own.
+ */
+export declare function toPrefillNames(tableName: string, columnName: string, bracketType: number, unique: boolean): Set<string>;
+export type PrefillInput = {
+    parentTable: Table;
+    childTable: Table;
+    keyKind: CandidateKey['kind'];
+    rows: Array<{
+        parentColumnId: string;
+        pick: ColumnPick | null;
+    }>;
+};
+/**
+ * Picks a child column for each empty row, in row order, where exactly one
+ * column holds a name of toPrefillNames; never the parent column itself, nor
+ * one a row holds or an earlier row was just given. Only the fills come back.
+ */
+export declare function prefillPicks({ collections, settings }: Pick<RootState, 'collections' | 'settings'>, { parentTable, childTable, keyKind, rows }: PrefillInput): Record<string, ColumnPick>;
+//# sourceMappingURL=prefill.d.ts.map