@dineug/erd-editor 3.9.2 → 4.0.0

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;
@@ -14,7 +15,36 @@ 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 = {
+    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/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;
@@ -9,6 +10,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";
@@ -16,6 +18,7 @@ export declare const KeyBindingName: {
     readonly addMemo: "addMemo";
     readonly removeTable: "removeTable";
     readonly removeColumn: "removeColumn";
+    readonly removeSelection: "removeSelection";
     readonly primaryKey: "primaryKey";
     readonly selectAllTable: "selectAllTable";
     readonly selectAllColumn: "selectAllColumn";
@@ -32,9 +35,20 @@ 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" | "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[]>;
 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.
+ */
+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/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/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/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

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

@@ -0,0 +1,10 @@
+import { AnyAction } from '@dineug/r-html';
+import { RootState } from '../../engine/state';
+import { MapColumnsDraft } from './mapping';
+/**
+ * The one batch a confirmed mapping writes, for a draft validateMapping passes:
+ * the new foreign key columns its New rows add, the data type changes the sync
+ * makes, then the relationship it adds or the columns it changes.
+ */
+export declare function toMapColumnsActions(state: RootState, draft: MapColumnsDraft, createId: () => string): AnyAction[];
+//# sourceMappingURL=toMapColumnsActions.d.ts.map

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

@@ -0,0 +1,45 @@
+import { RootState } from '../../engine/state';
+import { Relationship } from '../../internal-types';
+import { MapColumnsDraft } from './mapping';
+/**
+ * What keeps one row from being written: a place its stored lists cannot pair,
+ * a parent or picked child column gone from its table, no pick yet, or a child
+ * an earlier row already holds.
+ */
+export type MappingRowIssue = 'invalid' | 'removedParent' | 'unpicked' | 'removedChild' | 'inUse';
+/**
+ * What keeps the mapping as a whole from being written: rows that cover no key
+ * of the parent as it stands, every row on its own column, another relationship
+ * linking the same columns, or a mapping the relationship already holds.
+ */
+export type MappingSetIssue = 'noKey' | 'selfOnly' | 'duplicate' | 'unchanged';
+export type MappingIssues = {
+    rows: Array<MappingRowIssue | null>;
+    set: MappingSetIssue[];
+};
+type MappingState = Pick<RootState, 'doc' | 'collections' | 'settings'>;
+type DraftEnds = {
+    startTableId: string;
+    endTableId: string;
+    relationship?: Relationship;
+};
+/** The tables a draft maps between, read from the relationship it edits. */
+export declare function getDraftEnds({ collections }: Pick<RootState, 'collections'>, draft: MapColumnsDraft): DraftEnds | null;
+/**
+ * The issues of each row and of the mapping as a whole, read against the state
+ * as it stands, which the dialog shows and the write checks again on landing.
+ * A row past the first issue it has reports that one.
+ */
+export declare function validateMapping(state: MappingState, draft: MapColumnsDraft): MappingIssues;
+/** Whether any issue but the set issues given stands in the way. */
+export declare const hasMappingIssues: ({ rows, set }: MappingIssues, ignore?: MappingSetIssue[]) => boolean;
+/** Whether the tables a draft maps between, and the relationship it edits, are all still there. */
+export declare function hasMappingTargets(state: Pick<RootState, 'doc' | 'collections'>, draft: MapColumnsDraft): boolean;
+/**
+ * Whether the state already holds what the draft would write: every row on a
+ * live column it already pairs, in the relationship it edits, or in one from
+ * the same parent to the same child a peer or an agent made first.
+ */
+export declare function isSameResult(state: Pick<RootState, 'doc' | 'collections'>, draft: MapColumnsDraft): boolean;
+export {};
+//# sourceMappingURL=validate.d.ts.map

package/dist/utils/memo.d.ts

@@ -0,0 +1,4 @@
+import { RootState } from '../engine/state';
+/** Whether the document shows its memos, which Show.hideMemo hides while set, as View Option's Memos does. */
+export declare const isMemoShown: ({ settings }: RootState) => boolean;
+//# sourceMappingURL=memo.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
@@ -52,6 +58,8 @@ export type AMLEntity = {
     name: string;
     alias: string;
     comment: string;
+    /** The color property as a hex: a name as its own, a hex as written; '' otherwise. */
+    color: string;
     attributes: AMLAttribute[];
 };
 /** A struct and a custom type carry neither field, which is what stops a lookup. */

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

@@ -12,6 +12,8 @@ export type Token = {
     kind: number;
     value: string;
     line: number;
+    /** The token's start in the source, which tells touching tokens from spaced ones. */
+    offset: number;
 };
 export declare function tokenize(source: string): Token[];
 //# sourceMappingURL=tokenizer.d.ts.map

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

@@ -38,6 +38,8 @@ export type DBMLTable = {
     name: string;
     alias: string;
     comment: string;
+    /** headercolor as written when it is #rgb or #rrggbb; '' otherwise. */
+    color: string;
     columns: DBMLColumn[];
     indexes: DBMLIndex[];
 };
@@ -45,10 +47,22 @@ 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 DBMLTableName = Pick<DBMLEndpoint, 'schemaName' | 'tableName'>;
+export type DBMLTableGroup = {
+    name: string;
+    /** color as written when it is #rgb or #rrggbb; '' otherwise. */
+    color: string;
+    /** One per member line, as written; resolving them is convert.ts's concern. */
+    tables: DBMLTableName[];
 };
 export type DBMLModel = {
     tables: DBMLTable[];
     refs: DBMLRef[];
+    tableGroups: DBMLTableGroup[];
     /** Keyed by the qualified name, so s.status and status stay apart. */
     enums: Record<string, string[]>;
     skipped: string[];