@dineug/erd-editor 3.9.1 → 3.10.0

package/dist/components/primitives/icon/icons.d.ts

@@ -4,7 +4,9 @@ export declare const ICON_VIEW_BOX = "0 0 24 24";
 export declare const ICON_STROKE_WIDTH = 2;
 export type IconNodeChild = IconNode[number];
 declare const LUCIDE_ICON: {
+    'arrow-down': IconNode;
     'arrow-right': IconNode;
+    'arrow-up': IconNode;
     atom: IconNode;
     braces: IconNode;
     brackets: IconNode;
@@ -13,6 +15,7 @@ declare const LUCIDE_ICON: {
     'chevron-down': IconNode;
     'chevron-right': IconNode;
     code: IconNode;
+    'columns-2': IconNode;
     contrast: IconNode;
     copy: IconNode;
     database: IconNode;
@@ -27,7 +30,9 @@ declare const LUCIDE_ICON: {
     'grip-vertical': IconNode;
     hand: IconNode;
     'key-round': IconNode;
+    lock: IconNode;
     maximize: IconNode;
+    'message-square': IconNode;
     minimize: IconNode;
     minus: IconNode;
     'moon-star': IconNode;
@@ -37,6 +42,9 @@ declare const LUCIDE_ICON: {
     plus: IconNode;
     'redo-2': IconNode;
     'refresh-cw': IconNode;
+    regex: IconNode;
+    replace: IconNode;
+    'replace-all': IconNode;
     'rotate-ccw-clock': IconNode;
     search: IconNode;
     settings: IconNode;
@@ -44,12 +52,13 @@ declare const LUCIDE_ICON: {
     spline: IconNode;
     'sticky-note': IconNode;
     sun: IconNode;
-    table: IconNode;
     'table-2': IconNode;
     'table-properties': IconNode;
+    'text-search': IconNode;
     'undo-2': IconNode;
     'wand-sparkles': IconNode;
     waypoints: IconNode;
+    'whole-word': IconNode;
     workflow: IconNode;
     x: IconNode;
 };

package/dist/components/quick-search/QuickSearch.styles.d.ts

@@ -1,6 +1,12 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const container: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const field: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const search: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const scope: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hint: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hintItem: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const empty: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const prefix: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const list: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const action: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const icon: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/components/quick-search/actions.d.ts

@@ -1,15 +1,38 @@
 import { DOMTemplateLiterals } from '@dineug/r-html';
 import { AppContext } from '../appContext';
+import { RootState } from '../../engine/state';
+import { FindReplaceQuery } from '../../utils/emitter';
+import { FindMatch } from '../../utils/find-replace';
 export type Action = {
     icon?: DOMTemplateLiterals | null;
     name: string;
     keywords?: string;
     shortcut?: string;
+    /** The table a row jumps to, whose keyword names the kind of row, not the table. */
+    tableId?: string;
+    /** What choosing the row types into the input, which stays open, instead of running a command. */
+    insert?: string;
     filter?: (app: AppContext) => boolean;
     perform?: (app: AppContext) => void;
     next?: Action[];
 };
+/**
+ * Whether a row holds the keyword: as typed, or by its Hangul letters, which
+ * an IME spells out one jamo at a time and a choseong search abbreviates.
+ */
+export declare function keywordHolder(keyword: string): (action: Action) => boolean;
+/**
+ * How loose a fuzzy hit may be: stricter than fuse.js's 0.6, which fuzzed most
+ * words to some command (memo to the relationships, #us to orders), while a
+ * typo such as tabel still finds New Table. A row holding the keyword stays.
+ */
+export declare const SEARCH_THRESHOLD = 0.4;
 export declare function searchActions(actions: Action[], keyword: string): Action[];
+/** The palette's top level: the commands of every tab, then a jump to each table, which only the # prefix lists. */
 export declare function createScopeActions(app: AppContext): Action[];
+/** The row for one field a search found, saying where it is, which stands the reader on it when chosen. */
+export declare function createMatchAction(state: RootState, match: FindMatch): Action;
+/** The row handing a search to Find and Replace, named with the count the panel opens on. */
+export declare function createShowAllAction(count: number, payload: FindReplaceQuery): Action;
 export declare const allScopeActions: Action[];
 //# sourceMappingURL=actions.d.ts.map

package/dist/components/quick-search/hangul.d.ts

@@ -0,0 +1,73 @@
+import { Chunk, FindChunksArgs } from 'highlight-words-core';
+import { Matcher, TextRange } from '../../utils/find-replace';
+export type HangulForms = {
+    /** The text spelled in jamo letter by letter and lower-cased, as disassemble spells it. */
+    jamo: string;
+    /** The initial of each syllable and each lone consonant, a cluster split in two, run together without the spaces. */
+    choseong: string;
+};
+/** A text's forms, spelled once and kept until the palette next opens or closes, since it reads every field again on each keystroke. */
+export declare function hangulFormsOf(text: string): HangulForms;
+/** Lets go of every form kept, as the palette opens and closes: they last one open and outlive no text the document dropped. */
+export declare function clearHangulForms(): void;
+export type HangulQuery = {
+    /** The keyword spelled in jamo, which the text's jamo has to hold. */
+    jamo: string;
+    /** The consonants of a keyword typed as initials alone, a cluster split in two, spaces dropped; null for any other keyword. */
+    choseong: string | null;
+};
+/**
+ * How a keyword reads as a Hangul search, or null when it holds no Hangul and
+ * the palette matches as it always has.
+ *
+ * @example
+ * hangulQueryOf('ㅅㅇㅈ'); // { jamo: 'ㅅㅇㅈ', choseong: 'ㅅㅇㅈ' }
+ * hangulQueryOf('ㅄ'); // { jamo: 'ㅂㅅ', choseong: 'ㅂㅅ' }
+ * hangulQueryOf('사요'); // { jamo: 'ㅅㅏㅇㅛ', choseong: null }
+ */
+export declare function hangulQueryOf(keyword: string): HangulQuery | null;
+/** How closely a text holds a Hangul keyword: all of it, from its start, or somewhere inside. */
+export declare const HangulTier: {
+    readonly exact: 0;
+    readonly prefix: 1;
+    readonly inside: 2;
+};
+export type HangulTier = (typeof HangulTier)[keyof typeof HangulTier];
+/**
+ * How closely a text holds a Hangul keyword, by its jamo or, for a keyword of
+ * initials, by the initials of its syllables; null when it holds it neither way.
+ */
+export declare function hangulTier(text: string, query: HangulQuery): HangulTier | null;
+/**
+ * Every place a text holds a Hangul keyword, as whole letters of the text in
+ * order of where they start, so a jamo typed mid-syllable covers the syllables
+ * it spells: 상 in 사용자 covers 사용.
+ */
+export declare function hangulRanges(text: string, query: HangulQuery): TextRange[];
+/** Where a text holds the keyword: as typed, which Find and Replace finds too, or by its Hangul letters alone, and how closely. */
+export type TextHit = TextRange & ({
+    literal: true;
+} | {
+    literal: false;
+    tier: HangulTier;
+});
+/**
+ * The first place a text holds the keyword: as typed, or failing that by its
+ * Hangul letters, which only the palette reads.
+ */
+export declare function matchText(text: string, matcher: Matcher, hangul: HangulQuery | null): TextHit | null;
+/**
+ * Hits in a Hangul search's order: those holding the keyword as typed first,
+ * as they came, the way a search without Hangul lists them, then those only its
+ * letters hold, closest first and as they came within a tier.
+ */
+export declare function rankHits<T extends {
+    hit: TextHit;
+}>(hits: T[]): T[];
+/**
+ * The chunks a palette row lights up: each word where the text holds it as
+ * typed, and a Hangul word where the text holds it by its letters, widened to
+ * whole syllables. HighlightedText merges the ones that overlap.
+ */
+export declare function findPaletteChunks(args: FindChunksArgs): Chunk[];
+//# sourceMappingURL=hangul.d.ts.map

package/dist/components/quick-search/paletteQuery.d.ts

@@ -0,0 +1,37 @@
+import { ValuesType } from '../../internal-types';
+export declare const PaletteScope: {
+    readonly tables: "tables";
+    readonly columns: "columns";
+    readonly text: "text";
+    readonly help: "help";
+};
+export type PaletteScope = ValuesType<typeof PaletteScope>;
+export type PalettePrefix = {
+    prefix: string;
+    scope: PaletteScope;
+    label: string;
+    description: string;
+};
+/** The characters that, typed first, narrow the palette to one kind of row, in the order its hint lists them. */
+export declare const PALETTE_PREFIXES: ReadonlyArray<PalettePrefix>;
+export type PaletteQuery = {
+    /** The kind of row the prefix asks for, or null with no prefix, which lists the commands. */
+    scope: PaletteScope | null;
+    /** What is searched for, without the prefix, the space after it or the table part. */
+    keyword: string;
+    /** The table part of a column search, the text before its first dot; null when it has no dot. */
+    table: string | null;
+};
+/** The label the palette shows beside its input while a prefix narrows the list. */
+export declare const scopeLabel: (scope: PaletteScope) => string;
+/**
+ * Reads what is typed into the palette: a prefix counts only as the first
+ * character past any space, in its full-width form too, a space may follow it,
+ * and a column search splits on its first dot.
+ *
+ * @example
+ * parsePaletteQuery('@users.em'); // { scope: 'columns', keyword: 'em', table: 'users' }
+ * parsePaletteQuery(':login email'); // { scope: 'text', keyword: 'login email', table: null }
+ */
+export declare function parsePaletteQuery(value: string): PaletteQuery;
+//# sourceMappingURL=paletteQuery.d.ts.map

package/dist/components/quick-search/scopedActions.d.ts

@@ -0,0 +1,41 @@
+import { AppContext } from '../appContext';
+import { FindField } from '../../utils/find-replace';
+import { Action } from './actions';
+import { PaletteQuery, PaletteScope } from './paletteQuery';
+/** How many rows a prefixed list shows, few enough to draw at once. */
+export declare const SCOPED_ACTION_LIMIT = 100;
+/** What the colon searches: the free text, never a name. */
+export declare const TEXT_FIELDS: FindField[];
+/**
+ * The rows of a level a scope hands to the fuzzy search: the commands without
+ * a prefix, the tables after # alone, and none for a scope whose rows are read
+ * from the document. A submenu holds commands only.
+ */
+export declare function scopeBase(actions: Action[], scope: PaletteScope | null): Action[];
+/**
+ * What the top level lists for a query, from the fuzzy hits of its scope: the
+ * commands, then the prefixes when none holds the keyword; the tables; or rows
+ * read from the document for the columns, the free text and the help.
+ */
+export declare function paletteRows(app: AppContext, found: Action[], { scope, keyword, table }: PaletteQuery): Action[];
+/**
+ * The table rows the keyword fuzzes to, those holding it as typed or by its
+ * Hangul letters first, up to the scoped limit, past which a table whose name
+ * the panel finds it in hands the search to Find and Replace over the names.
+ */
+export declare function rankTableActions(app: AppContext, found: Action[], keyword: string): Action[];
+/**
+ * One row a field of the kinds given holding the keyword, Hangul letters too,
+ * or every column or text, up to the scoped limit, past which one holding it as
+ * typed hands it to Find and Replace over those kinds, without the table part.
+ */
+export declare function createFieldActions(app: AppContext, fields: FindField[], keyword: string, table?: string | null): Action[];
+/** The prefixes as rows, each typing its character into the input when chosen; a keyword fuzzes them. */
+export declare function createHelpActions(keyword?: string): Action[];
+/**
+ * The prefixes that search the document as rows offering the keyword to one,
+ * what a search with no prefix lists below its commands once none holds it:
+ * choosing one types its prefix before the keyword, so users becomes #users.
+ */
+export declare function createPrefixActions(keyword: string): Action[];
+//# sourceMappingURL=scopedActions.d.ts.map

package/dist/components/visualization/table/column/Column.d.ts

@@ -6,6 +6,10 @@ export type ColumnProps = {
     widthDataType: number;
     widthDefault: number;
     widthComment: number;
+    /** The room the table keeps for alternate key marks, 0 while it draws none. */
+    widthAlternateKey?: number;
+    /** The mark this row carries in that room, last, as the ERD scene draws it. */
+    alternateKey?: string;
 };
 declare const Column: FC<ColumnProps>;
 export default Column;

package/dist/constants/layout.d.ts

@@ -48,6 +48,12 @@ export declare const COLUMN_MIN_WIDTH = 60;
 export declare const COLUMN_NOT_NULL_WIDTH = 35;
 export declare const COLUMN_UNIQUE_WIDTH = 22;
 export declare const COLUMN_AUTO_INCREMENT_WIDTH = 15;
+/**
+ * The advance one alternate key mark character takes. The mark is drawn at the
+ * cell size in the code face, whose glyphs all advance about 0.6 of the size,
+ * so a table is sized by the mark's length alone, in a headless peer too.
+ */
+export declare const COLUMN_ALTERNATE_KEY_CHAR_WIDTH: number;
 export declare const COLUMN_PADDING = 2;
 export declare const COLUMN_HEIGHT: number;
 /** The table icon a view card draws beside its name, at the reference's 1rem. */
@@ -98,6 +104,13 @@ export declare const MEMO_MIN_HEIGHT = 100;
 export declare const MINIMAP_SIZE = 150;
 export declare const MINIMAP_MARGIN = 20;
 export declare const TOOLBAR_HEIGHT = 30;
+/**
+ * The padding around the Table Properties body. A band stuck to an edge of the
+ * body reaches back over it, so no row scrolls into sight behind the band.
+ */
+export declare const TABLE_PROPERTIES_BODY_PADDING = 12;
+/** How many rows the Table Properties index order shows before it scrolls the rest. */
+export declare const INDEX_ORDER_MAX_ROWS = 3;
 export declare const DIFF_TREE_WIDTH = 200;
 /**
  * How thick a relationship connector is drawn. A whole number rather than a

package/dist/constants/open.d.ts

@@ -6,6 +6,7 @@ export declare const Open: {
     readonly themeBuilder: "themeBuilder";
     readonly diffViewer: "diffViewer";
     readonly timeTravel: "timeTravel";
+    readonly findReplace: "findReplace";
 };
 export type Open = ValuesType<typeof Open>;
 //# sourceMappingURL=open.d.ts.map

package/dist/constants/schema.d.ts

@@ -16,6 +16,8 @@ export declare const Show: {
     readonly columnUnique: 64;
     readonly columnNotNull: 128;
     readonly relationship: 256;
+    readonly columnAlternateKey: 512;
+    readonly hideReferentialAction: 1024;
 };
 export declare const ColumnType: {
     readonly columnName: 1;
@@ -81,6 +83,15 @@ export declare const StartRelationshipType: {
     readonly dash: 2;
 };
 export declare const StartRelationshipTypeList: readonly number[];
+export declare const ReferentialAction: {
+    readonly none: 1;
+    readonly noAction: 2;
+    readonly cascade: 4;
+    readonly setNull: 8;
+    readonly setDefault: 16;
+    readonly restrict: 32;
+};
+export declare const ReferentialActionList: readonly number[];
 export declare const Direction: {
     readonly left: 1;
     readonly right: 2;
@@ -112,5 +123,7 @@ export declare const CANVAS_SIZE_MIN: 2000;
 export declare const CANVAS_ZOOM_MAX: 1.5;
 export declare const CANVAS_ZOOM_MIN: 0.1;
 export declare const BracketTypeMap: Record<number, string>;
+/** The clause each action writes after ON DELETE / ON UPDATE; none writes none. */
+export declare const ReferentialActionToSQL: Record<number, string>;
 export declare const ColumnTypeToName: Record<number, string>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/engine/index.d.ts

@@ -1,2 +1,2 @@
-export { createReplicationStore, type ReplicationStore, } from './replication-store';
+export { createReplicationStore, type ReplicationChange, type ReplicationStore, } from './replication-store';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/index.js

@@ -1,34 +1,40 @@
-import { Li as e, Tn as t, Zn as n, b as r, c as i, g as a, m as o, rn as s, t as c, tt as l, ya as u } from "../store-hooks-DuNN9ZKu.js";
-import { n as d, t as f } from "../schemaGCService-_8A8Oh9Q.js";
-import { isEmpty as p } from "es-toolkit/compat";
+import { Ln as e, Va as t, _ as n, dr as r, h as i, n as a, nt as o, r as s, t as c, u as l, un as u, x as d } from "../loadValue-Mdc5K4qO.js";
+import { n as f, r as p } from "../schemaGCService-CZtGFh2z.js";
 import { omit as m } from "es-toolkit";
 import { Observable as h, Subject as g, debounceTime as _, map as v } from "rxjs";
 //#region src/engine/replication-store.ts
 var y = { change: "change" };
 function b(b) {
-	let x = /* @__PURE__ */ new Set(), S = a(b), C = i(S, !1);
-	C.dispatchSync(t({
+	let x = /* @__PURE__ */ new Set(), S = n(b), C = l(S, !1);
+	C.dispatchSync(e({
 		width: 0,
 		height: 0
 	}));
-	let w = c(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(o(r), _(200)), D = /* @__PURE__ */ new Set(), O = new f(), k = (e) => (D.has(e) || D.add(e), () => {
+	let w = a(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(i(d), _(200)), D = /* @__PURE__ */ new Set(), O = null, k = (e) => (D.has(e) || D.add(e), () => {
 		D.delete(e);
 	}), A = (e, t) => {
 		D.forEach((n) => {
 			let r = Reflect.get(n, e);
-			s(r, t);
-		});
-	}, j = (t) => {
-		let r = e(t);
-		C.dispatchSync(l(p(r) ? "{}" : r)), O.run(u(C.state)).then((e) => {
-			(e.tableIds.length || e.tableColumnIds.length || e.relationshipIds.length || e.indexIds.length || e.indexColumnIds.length || e.memoIds.length) && (d(C.state, e), C.dispatchSync(n()));
+			u(r, t);
 		});
+	}, j = (e) => {
+		O = null, C.dispatchSync(o(c(e)));
+		let n = f(t(C.state));
+		Object.values(n).some((e) => e.length) && (p(C.state, n), C.dispatchSync(r())), s(C.state, S);
 	}, M = (e) => {
 		T.next([e].flat());
 	};
-	return x.add(E.subscribe(() => A(y.change, void 0))).add(T.pipe(o(r), v((e) => e.map((e) => m(e, ["tags"])))).subscribe(C.dispatchSync)), Object.freeze({
+	return x.add(E.subscribe(() => {
+		let e = t(C.state), n = O !== null && e !== O;
+		O !== null && (O = e), A(y.change, {
+			value: e,
+			changed: n
+		});
+	})).add(T.pipe(i(d), v((e) => e.map((e) => m(e, ["tags"])))).subscribe((e) => {
+		O ??= t(C.state), C.dispatchSync(e);
+	})), Object.freeze({
 		get value() {
-			return u(C.state);
+			return t(C.state);
 		},
 		on: k,
 		setInitialValue: j,

package/dist/engine/modules/relationship/actions.d.ts

@@ -6,12 +6,17 @@ export declare const ActionType: {
     readonly addRelationship: "relationship.add";
     readonly removeRelationship: "relationship.remove";
     readonly changeRelationshipType: "relationship.changeType";
+    readonly changeRelationshipOnDelete: "relationship.changeOnDelete";
+    readonly changeRelationshipOnUpdate: "relationship.changeOnUpdate";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 export type ActionMap = {
     [ActionType.addRelationship]: {
         id: string;
         relationshipType: number;
+        /** Absent from an editor that predates the referential actions. */
+        onDelete?: number;
+        onUpdate?: number;
         start: RelationshipPoint;
         end: RelationshipPoint;
     };
@@ -22,6 +27,14 @@ export type ActionMap = {
         id: string;
         value: number;
     };
+    [ActionType.changeRelationshipOnDelete]: {
+        id: string;
+        value: number;
+    };
+    [ActionType.changeRelationshipOnUpdate]: {
+        id: string;
+        value: number;
+    };
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
 type RelationshipPoint = {

package/dist/engine/modules/relationship/atom.actions.d.ts

@@ -3,6 +3,8 @@ export declare const addRelationshipAction: {
     (payload: {
         id: string;
         relationshipType: number;
+        onDelete?: number;
+        onUpdate?: number;
         start: {
             tableId: string;
             columnIds: string[];
@@ -14,6 +16,8 @@ export declare const addRelationshipAction: {
     }): import('@dineug/r-html').AnyAction<{
         id: string;
         relationshipType: number;
+        onDelete?: number;
+        onUpdate?: number;
         start: {
             tableId: string;
             columnIds: string[];
@@ -46,16 +50,42 @@ export declare const changeRelationshipTypeAction: {
     toString(): string;
     type: string;
 };
+export declare const changeRelationshipOnDeleteAction: {
+    (payload: {
+        id: string;
+        value: number;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        value: number;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const changeRelationshipOnUpdateAction: {
+    (payload: {
+        id: string;
+        value: number;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        value: number;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const relationshipReducers: {
     "relationship.add": ReducerType<"relationship.add">;
     "relationship.remove": ReducerType<"relationship.remove">;
     "relationship.changeType": ReducerType<"relationship.changeType">;
+    "relationship.changeOnDelete": ReducerType<"relationship.changeOnDelete">;
+    "relationship.changeOnUpdate": ReducerType<"relationship.changeOnUpdate">;
 };
 export declare const actions: {
     addRelationshipAction: {
         (payload: {
             id: string;
             relationshipType: number;
+            onDelete?: number;
+            onUpdate?: number;
             start: {
                 tableId: string;
                 columnIds: string[];
@@ -67,6 +97,8 @@ export declare const actions: {
         }): import('@dineug/r-html').AnyAction<{
             id: string;
             relationshipType: number;
+            onDelete?: number;
+            onUpdate?: number;
             start: {
                 tableId: string;
                 columnIds: string[];
@@ -99,5 +131,27 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    changeRelationshipOnDeleteAction: {
+        (payload: {
+            id: string;
+            value: number;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            value: number;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    changeRelationshipOnUpdateAction: {
+        (payload: {
+            id: string;
+            value: number;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            value: number;
+        }>;
+        toString(): string;
+        type: string;
+    };
 };
 //# sourceMappingURL=atom.actions.d.ts.map

package/dist/engine/modules/relationship/fkColumns.d.ts

@@ -1,9 +1,26 @@
 import { AnyAction } from '@dineug/r-html';
 import { Column } from '../../../internal-types';
+/** The start table's name and the names the end table's columns hold. */
+export type ForeignKeyNaming = {
+    startTableName: string;
+    endColumnNames: string[];
+};
+/**
+ * Tells a name of one word, id, ID, Id, UUID, id2 or 회원번호, from one of
+ * several, user_id, userId, UserID, IDCard or 회원ID: one word is letters and
+ * digits with none of the breaks CASE_BOUNDARY finds, read past marks and digits.
+ */
+export declare const isSingleWord: (name: string) => boolean;
+/**
+ * Names the foreign key column of each single word key after the start table,
+ * user_id for the key id of user, keeps other key names, and numbers a name
+ * already taken, user_id_2, without case; free names, kept first, claim first.
+ */
+export declare function toForeignKeyNames(startTableName: string, keyNames: string[], endColumnNames: string[]): string[];
 /**
  * Adds a NOT NULL copy of each start column to the end table under the id at
- * the same index of endColumnIds, carrying its name, data type, default and
- * comment. The caller owns the ids because the relationship needs them too.
+ * the same index of endColumnIds, named by toForeignKeyNames, carrying its data
+ * type, default and comment. The caller owns the ids the relationship needs.
  */
-export declare const toForeignKeyActions: (startColumns: Column[], endTableId: string, endColumnIds: string[]) => AnyAction[];
+export declare const toForeignKeyActions: (startColumns: Column[], endTableId: string, endColumnIds: string[], { startTableName, endColumnNames }: ForeignKeyNaming) => AnyAction[];
 //# sourceMappingURL=fkColumns.d.ts.map

package/dist/engine/modules/relationship/generator.actions.d.ts

@@ -1,11 +1,14 @@
 import { GeneratorAction } from '../../generator.actions';
+import { ActionMap, ActionType } from './actions';
+type ReferentialActions = Pick<ActionMap[typeof ActionType.addRelationship], 'onDelete' | 'onUpdate'>;
 /**
  * Draws a relationship between two live tables in one batch, giving the start
  * table a primary key first when it has none and copying the keys onto the end
  * table, which may be the start table itself. An unknown table yields nothing.
  */
-export declare const addRelationshipAction$: (startTableId: string, endTableId: string, relationshipType: number) => GeneratorAction;
+export declare const addRelationshipAction$: (startTableId: string, endTableId: string, relationshipType: number, referentialActions?: ReferentialActions) => GeneratorAction;
 export declare const actions$: {
-    addRelationshipAction$: (startTableId: string, endTableId: string, relationshipType: number) => GeneratorAction;
+    addRelationshipAction$: (startTableId: string, endTableId: string, relationshipType: number, referentialActions?: ReferentialActions) => GeneratorAction;
 };
+export {};
 //# sourceMappingURL=generator.actions.d.ts.map

package/dist/engine/modules/relationship/history.d.ts

@@ -3,5 +3,7 @@ export declare const relationshipPushUndoHistoryMap: {
     "relationship.add": PushUndoHistory;
     "relationship.remove": PushUndoHistory;
     "relationship.changeType": PushUndoHistory;
+    "relationship.changeOnDelete": PushUndoHistory;
+    "relationship.changeOnUpdate": PushUndoHistory;
 };
 //# sourceMappingURL=history.d.ts.map

package/dist/engine/modules/relationship/hooks.d.ts

@@ -1,3 +1,14 @@
 import { Hook } from '../../hooks';
+import { RootState } from '../../state';
+/**
+ * Marks each relationship identifying when every column it ends on is a primary
+ * key. A load reads it off the columns again, as a key edit or a removal does.
+ */
+export declare function recalculateIdentification({ doc, collections }: RootState): void;
+/**
+ * Starts each relationship dashed when every column it ends on is not null and
+ * ringed otherwise, read off the columns as the identification is.
+ */
+export declare function recalculateStartRelationshipType({ doc, collections, }: RootState): void;
 export declare const hooks: Hook[];
 //# sourceMappingURL=hooks.d.ts.map

package/dist/engine/modules/table-column/hooks.d.ts

@@ -1,3 +1,9 @@
 import { Hook } from '../../hooks';
+import { RootState } from '../../state';
+/**
+ * Marks as a foreign key every column a relationship ends on, and only those,
+ * as a load leaves the marks to be read off the relationships again.
+ */
+export declare function validateForeignKeys({ doc, collections }: RootState): void;
 export declare const hooks: Hook[];
 //# sourceMappingURL=hooks.d.ts.map

package/dist/engine/replication-store.d.ts

@@ -9,10 +9,24 @@ declare const InternalActionType: {
 };
 type InternalActionType = ValuesType<typeof InternalActionType>;
 type InternalActionMap = {
-    [InternalActionType.change]: void;
+    [InternalActionType.change]: ReplicationChange;
+};
+/**
+ * What a change hands its listeners: the document serialized, and whether the
+ * change actions since the last change, or since the load, left it byte for
+ * byte as it was, as a scroll or a zoom the file does not save does.
+ */
+export type ReplicationChange = {
+    value: string;
+    changed: boolean;
 };
 export type ReplicationStore = {
     readonly value: string;
+    /**
+     * A change comes 200 ms after the last change action, even one that left the
+     * value as it was (changed false): a hub waits for each as a save, and a host
+     * writes nothing for such a one, whatever bytes its file holds.
+     */
     on: (listeners: Partial<ListenerRecord>) => Unsubscribe;
     setInitialValue: (value: string) => void;
     dispatch: (actions: Array<AnyAction> | AnyAction) => void;

package/dist/engine/rx-operators/flushOnNotifier.d.ts

@@ -6,4 +6,10 @@ import { StreamBufferOperator } from './groupByStreamActions';
  * pending emits nothing and an extra tick is harmless.
  */
 export declare const flushOnNotifier: (notifier$: Observable<unknown>) => StreamBufferOperator;
+/**
+ * Closes a stream buffer after groupByStreamActions' 200 ms quiet period, or
+ * at once when the notifier fires: the editor keeps its timing, and a host
+ * can still send what is held before it lets the store go.
+ */
+export declare const quietPeriodOrNotifier: (notifier$: Observable<unknown>, quietMs?: number) => StreamBufferOperator;
 //# sourceMappingURL=flushOnNotifier.d.ts.map