@dineug/erd-editor 3.8.0 → 3.9.0

package/README.md

@@ -138,7 +138,7 @@ erd-editor {
 
 | Method | Description |
 | --- | --- |
-| `setInitialValue(value: string)` | Load the initial document. Does not create a history entry. |
+| `setInitialValue(value: string)` | Load the initial document. Does not create a history entry, and clears the undo history, so nothing done before the load can be undone or redone onto it. |
 | `getSchemaSQL(vendor?)` | Export DDL. `vendor` is one of `Databricks`, `MariaDB`, `MSSQL`, `MySQL`, `Oracle`, `PostgreSQL`, `Snowflake`, `SQLite`; omit it to use the document's own setting. |
 | `setSchemaSQL(value: string)` | Parse a DDL string and **replace** the current document with it. Lands in the undo history; an empty string is ignored. |
 | `setSchemaGraphQL(value: string)` | Parse a GraphQL SDL string and **replace** the current document with it. Object types become tables, scalars map to the document's own dialect, and relationships are read from the fields that point at another type. Lands in the undo history; an empty string is ignored. |

package/dist/components/erd/canvas/column-drag-ghost/ColumnDragGhost.d.ts

@@ -0,0 +1,10 @@
+import { FC } from '@dineug/r-html';
+export type ColumnDragGhostProps = {};
+/**
+ * The rows a column drag carries, drawn on the presence layer under the
+ * pointer where the browser used to hang its drag image. Each keeps its name
+ * and type where its table lays them out, and none of it answers a hit.
+ */
+declare const ColumnDragGhost: FC<ColumnDragGhostProps>;
+export default ColumnDragGhost;
+//# sourceMappingURL=ColumnDragGhost.d.ts.map

package/dist/components/erd/canvas/column-drag-ghost/columnDragPointer.d.ts

@@ -0,0 +1,28 @@
+import { RootState } from '../../../../engine/state';
+import { Point, Table } from '../../../../internal-types';
+/**
+ * The pointer a column drag holds, in canvas units: where it is, where it took
+ * the rows it carries, and whether a drop target is under it right now.
+ */
+export type ColumnDragPointer = {
+    x: number;
+    y: number;
+    /** The pointer's offset from the top left of the rows it carries. */
+    grabX: number;
+    grabY: number;
+    over: boolean;
+};
+/**
+ * Takes hold of the rows a drag carries at the press on one of them. The ghost
+ * stacks them in drag order, so the pressed row sits that many rows down it.
+ */
+export declare function beginColumnDragPointer(root: RootState, table: Table, press: Point, { columnId, columnIds }: {
+    columnId: string;
+    columnIds: string[];
+}): void;
+/** Follows the pointer of a drag that began, and ignores one that never did. */
+export declare function moveColumnDragPointer(root: RootState, { x, y }: Point, over: boolean): void;
+export declare function endColumnDragPointer(root: RootState): void;
+/** Reads the pointer through the observable, so a render tracks it. */
+export declare function getColumnDragPointer(root: RootState): ColumnDragPointer | null;
+//# sourceMappingURL=columnDragPointer.d.ts.map

package/dist/components/erd/canvas/sceneTokens.d.ts

@@ -46,21 +46,31 @@ export declare const HIGH_LEVEL_FONT_SIZES: readonly [20, 24, 28, 35, 60];
 export declare const TABLE_INSET: number;
 /** The radius Table.styles rounds a table box with. */
 export declare const TABLE_CORNER_RADIUS = 6;
-/** The min-height Table.styles gives the colour bar across a table header. */
-export declare const HEADER_COLOR_HEIGHT = 4;
 /** The 1.5px underline EditInput draws for a focused, edited or shared cell. */
 export declare const FOCUS_BORDER_HEIGHT = 1.5;
 /** What the ring outside a table box costs, as outline and box-shadow both do. */
 export declare const RING_WIDTH = 1;
 /**
- * The drop shadow a view card sits on, which is what lifts it off the ground
- * the ERD canvas draws flat. The alpha is the shadow's own, since the shadow
- * colour token is opaque and the palette has no translucent spelling of it.
+ * The drop shadow a view card sits on, deeper than any a document box casts.
+ * The alpha is the shadow's own, since the minimap shadow token it borrows is
+ * an opaque black.
  */
 export declare const VIEW_CARD_SHADOW_BLUR = 20;
 export declare const VIEW_CARD_SHADOW_OFFSET_X = 0;
 export declare const VIEW_CARD_SHADOW_OFFSET_Y = 2;
 export declare const VIEW_CARD_SHADOW_OPACITY = 0.4;
+/** A drop shadow as the five konva shadow attrs a body sets from it. */
+export type CardShadow = {
+    color: string;
+    blur: number;
+    offsetX: number;
+    offsetY: number;
+    opacity: number;
+};
+/** The shadow a view card casts, in the colour of the token it borrows. */
+export declare function viewCardShadow(color: string): CardShadow;
+export declare const DOCUMENT_CARD_SHADOW_BLUR = 10;
+export declare const DOCUMENT_CARD_SHADOW_OFFSET_Y = 2;
 /**
  * The bloom a lit view card wears, drawn as a shadow on a stroke and never as
  * a filled sibling: a fill behind the body would have to be reordered under it,
@@ -77,6 +87,12 @@ export declare const TRANSPARENT = "transparent";
  * keeps the whole padded box clickable the way its div did.
  */
 export declare const HIT_FILL = "transparent";
+/**
+ * The shadow a document table or memo casts, in a colour carrying its alpha. No
+ * shadow sets no attr at all, so the canvas never spends a blur on nothing, and
+ * a scene with no theme above it reads every token as undefined.
+ */
+export declare function documentCardShadow(color: string | undefined): CardShadow | null;
 /** The hand a clickable scene node asks for, as the dom scene spelt it in css. */
 export declare const CURSOR_POINTER = "pointer";
 /** The beam a textarea carried on its own, which a drawn body has to ask for. */
@@ -86,9 +102,19 @@ export declare const CURSOR_INHERIT = "";
 /**
  * Points the stage container at a cursor. A konva node carries none of its own,
  * so the container is where the css the dom scene put on an element now lives.
+ * Under a hold the cursor is only noted, for the release to write back.
  *
  * @example
  * on:mouseenter={(event) => setSceneCursor(event, CURSOR_POINTER)}
  */
 export declare function setSceneCursor(event: ScenePointerEvent, cursor: string): void;
+/**
+ * Keeps the container on a cursor for a mouse gesture, whatever the pointer runs
+ * over, and hands back the release that shows what the last hover asked for. A
+ * touch has no cursor to keep, so its press holds nothing.
+ *
+ * @example
+ * drag$.subscribe(handleMove).add(holdSceneCursor(event, 'ew-resize'));
+ */
+export declare function holdSceneCursor(event: ScenePointerEvent, cursor: string): () => void;
 //# sourceMappingURL=sceneTokens.d.ts.map

package/dist/components/erd/canvas/table/cellLayout.d.ts

@@ -18,9 +18,9 @@ export type ColumnCellSlot = CellSlot & {
 /** Where the header cell row starts inside a table group. */
 export declare const HEADER_CELLS_X: number;
 /**
- * How far down a table group the header cells start. The document keeps the
- * icon band above them; a view draws no icon there, so its cells begin at the
- * inset itself.
+ * How far down a table group the header cells start. The document band starts
+ * at the top border, over the card's top padding, and keeps its own room over
+ * the line; a view sets its icon line inside that padding instead.
  */
 export declare function getHeaderCellsY(source?: GeometrySource): number;
 /**
@@ -80,9 +80,9 @@ export declare function getColumnCellsX(source?: GeometrySource): number;
 /** The comment width a table draws at, clamped by the setting when it is set. */
 export declare function getWidthComment(state: RootState, table: Table): number;
 /**
- * The name and comment boxes across a table header. One list feeds both the
- * scene that draws them and the overlay that edits them, so an editor can never
- * sit anywhere but on the text it replaces. A view draws the name alone.
+ * The name and comment boxes past a header's table icon. One list feeds the
+ * scene that draws them and the overlay that edits them, so an editor never
+ * sits anywhere but on the text it replaces. A view draws the name alone.
  */
 export declare function getHeaderCellSlots(state: RootState, table: Table, source?: GeometrySource): CellSlot[];
 /**

package/dist/components/erd/canvas/table/colorEdge.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The svg path of the colour a table wears along its left edge: the part of
+ * the card's outline left of the strip's width, so it follows both rounded
+ * corners where a rect that narrow could only round its own.
+ *
+ * @example
+ * <k-path data={getColorEdgePath(rect.height)} fill={table.ui.color} />
+ */
+export declare function getColorEdgePath(height: number): string;
+//# sourceMappingURL=colorEdge.d.ts.map

package/dist/components/erd/canvas/table/column/Column.d.ts

@@ -1,5 +1,6 @@
 import { FC } from '@dineug/r-html';
 import { SceneMouseEvent } from '../../sceneTokens';
+import { DiffPaths } from '../../../diff-viewer/diff';
 import { Column } from '../../../../../internal-types';
 import { GeometrySource } from '../../../../../utils/draw-relationship/geometrySource';
 export type ColumnProps = {
@@ -15,17 +16,25 @@ export type ColumnProps = {
      * for. Decided by the scene, which walks the links once for every card.
      */
     related?: boolean;
+    /**
+     * What the diff pane this row is drawn in changed of its column, which tints
+     * those cells. A prop for the reason source is one, and null outside a pane.
+     */
+    diffPaths?: DiffPaths | null;
     /**
      * How far the light has come up on the card this row is drawn in, which is
      * what the row tint and the type cell above are both drawn at. One number, so
      * the two of them come up over the one span of time and a document row reads none of it.
      */
     litAlpha?: number;
-    /** Whether a view rules a line under this row, which every row but the last does. */
+    /**
+     * Whether the card rules a line under this row. A view card rules one under
+     * every row but the last, and a document table rules none.
+     */
     divider?: boolean;
     /**
-     * Whether this is the row a view card ends at. A view draws no padding under
-     * its rows, so the last one meets the card's bottom border and takes the two
+     * Whether this is the row a card ends at. A card draws no padding under its
+     * rows, so the last one meets the card's bottom border and takes the two
      * corners it is rounded by, or its square tint would stand outside them.
      */
     last?: boolean;

package/dist/components/erd/canvas/useMoveEntity.d.ts

@@ -9,6 +9,12 @@ export type MoveEntityOptions = {
     selectType: SelectType;
     /** The scene kinds a drag never starts from in the scene pressed, as closest read their classes. */
     blockedKinds: (source: GeometrySource) => readonly string[];
+    /**
+     * The kinds whose press is a click as well: the drag waits for the pointer
+     * to travel before it lifts the entity into the drag layer, which takes it
+     * off the hit canvas, so a click or a double click there lands where it pressed.
+     */
+    clickKinds?: (source: GeometrySource) => readonly string[];
     /**
      * The scene the component already stands in, handed down rather than read
      * again here, so a leaf pays for one context subscription and not two.

package/dist/components/erd/diff-viewer/diff.d.ts

@@ -1,10 +1,13 @@
 import { RootState } from '../../../engine/state';
 import { Column, Table } from '../../../internal-types';
+import { Theme } from '../../../themes/tokens';
 /**
  * Map<uuid, [tag, Map<path, diff>]>
  */
 export type DiffMap = Map<string, DiffTuple>;
-type DiffTuple = [string, Map<string, number>];
+/** Map<path, diff> for one entity, each path spelled as the FocusType of the cell showing it. */
+export type DiffPaths = Map<string, number>;
+type DiffTuple = [string, DiffPaths];
 type NameToTableMap = Map<string, {
     table: Table;
     nameToColumnMap: Map<string, Column>;
@@ -15,6 +18,10 @@ export declare const Diff: {
 };
 export declare function diffState(prevState: RootState, state: RootState): [DiffMap, DiffMap];
 export declare function getNameToTableMap({ doc: { tableIds }, collections, }: RootState): NameToTableMap;
-export declare function getDiffStyle(diff: number, diffMap: DiffMap): HTMLStyleElement;
+/**
+ * The background a cell of one entity sits on in a diff pane: the insert or the
+ * delete colour its own path carries, and null for a path that did not change.
+ */
+export declare function diffFill(theme: Theme, paths: DiffPaths | null | undefined, path: string): string | null;
 export {};
 //# sourceMappingURL=diff.d.ts.map

package/dist/components/erd/diff-viewer/diffContext.d.ts

@@ -0,0 +1,9 @@
+import { DiffMap } from './diff';
+import { Ctx } from '../../../internal-types';
+/**
+ * The changes a diff pane tints its cells by. ErdViewer alone provides one, so
+ * every other scene reads null and draws no tint, and no node for one either.
+ */
+export declare const diffContext: import('@dineug/r-html').Context<DiffMap | null>;
+export declare const useDiffMap: (ctx: Ctx) => import('@dineug/r-html').Ref<DiffMap | null>;
+//# sourceMappingURL=diffContext.d.ts.map

package/dist/components/primitives/context-menu/context-menu-content/ContextMenuContent.d.ts

@@ -3,6 +3,8 @@ export type ContextMenuContentProps = {
     id: string;
     x: number;
     y: number;
+    fit?: boolean;
+    flipX?: number;
     children?: DOMTemplateLiterals;
 };
 declare const ContextMenuContent: FC<ContextMenuContentProps>;

package/dist/components/primitives/context-menu/context-menu-content/fitMenu.d.ts

@@ -0,0 +1,20 @@
+export type MenuBox = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export type WindowSize = {
+    width: number;
+    height: number;
+};
+/**
+ * How far a menu drawn at box moves into the window: back from the right and
+ * bottom edges, never past the left and top. A submenu the right edge cuts
+ * flips to end at flipRight instead, unless the left edge would cut it more.
+ */
+export declare function fitMenu(box: MenuBox, view: WindowSize, flipRight?: number): {
+    dx: number;
+    dy: number;
+};
+//# sourceMappingURL=fitMenu.d.ts.map

package/dist/components/table-view/Table.styles.d.ts

@@ -1,6 +1,11 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+/** The band the name stands in, one input line and its room as in the scene. */
 export declare const header: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * The colour along the left edge, over the border. The box is wider than the
+ * corner it rounds and cut back to the strip, since a radius wider than its
+ * own box is scaled down to fit and would no longer follow the card's.
+ */
 export declare const headerColor: import('@dineug/r-html').CSSTemplateLiterals;
-export declare const headerButtonWrap: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const headerInputWrap: import('@dineug/r-html').CSSTemplateLiterals;
 //# sourceMappingURL=Table.styles.d.ts.map

package/dist/components/table-view/column/useColumnCell.d.ts

@@ -8,6 +8,11 @@ export type ColumnCellProps = {
     value: string;
     onEditEnd?: () => void;
 };
+/**
+ * The hints a typed data type offers: a fuzzy match over the names, or none
+ * for blank text and for text that has gone past a whole name.
+ */
+export declare function searchDataTypeHints(hints: DataTypeHint[], value: string): DataTypeHint[];
 /**
  * Data type autocomplete state and key handling for a column cell, shared by
  * the DOM cell and by the Konva cell that replaces it.

package/dist/components/visualization/Visualization.styles.d.ts

@@ -3,6 +3,9 @@
  * Stage, so nothing here is ever larger than the box it sits in.
  */
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
-/** The Stage container, viewport sized, which konva fills with its own canvas. */
+/**
+ * The Stage container, viewport sized, which konva fills with its own canvas.
+ * It takes every touch itself, so a pinch on it zooms the graph and not the page.
+ */
 export declare const stage: import('@dineug/r-html').CSSTemplateLiterals;
 //# sourceMappingURL=Visualization.styles.d.ts.map

package/dist/components/visualization/captureDrag.d.ts

@@ -0,0 +1,14 @@
+import { KonvaEventObject } from 'konva/lib/Node';
+import { Subscription } from 'rxjs';
+import { DragMove } from '../../utils/globalEventObservable';
+export type CapturedDragObserver = {
+    next: (move: DragMove) => void;
+    complete: () => void;
+};
+/**
+ * Follows a drag pressed on a konva shape, holding the pointer on that shape
+ * until the lift. Konva tests a move against the hit graph the last draw left,
+ * so a pointer faster than a draw would otherwise leave the shape it holds.
+ */
+export declare function captureDrag(event: KonvaEventObject<Event>, { next, complete }: CapturedDragObserver): Subscription;
+//# sourceMappingURL=captureDrag.d.ts.map

package/dist/components/visualization/useViewGestures.d.ts

@@ -11,8 +11,8 @@ export type ViewGestureOptions = {
 };
 /**
  * The gestures a view scene takes on its box: the wheel moves the screen and
- * with the modifier zooms it, a press on the background pans, and with the
- * modifier it opens the marquee of this scene. Every one lands in the view named.
+ * with the modifier zooms it, as a pinch does, a press on the background pans,
+ * and with the modifier it opens the marquee. Every one lands in the view named.
  *
  * @example
  * const { handleWheel, handleMousedown } = useViewGestures(ctx, { root, canvas, source });

package/dist/constants/layout.d.ts

@@ -2,23 +2,48 @@ export declare const START_X = 200;
 export declare const START_Y = 100;
 export declare const START_ADD = 50;
 export declare const DUPLICATE_MIN_MOVE = 4;
+/**
+ * How far, in screen px, a press on a cell that also takes a click travels
+ * before it carries its entity, so a double click that wobbles still edits.
+ */
+export declare const CLICK_DRAG_MIN_MOVE = 4;
 export declare const DEFAULT_WIDTH = 1200;
 export declare const DEFAULT_HEIGHT: number;
 /** The px a table cell's text is drawn at, which the scene and the view header scale read. */
 export declare const CELL_FONT_SIZE = 12;
 export declare const INPUT_HEIGHT = 20;
 export declare const INPUT_MARGIN_RIGHT = 8;
+/** The height of one row in the data type autocomplete list. */
+export declare const DATA_TYPE_HINT_ROW_HEIGHT = 20;
+/** How many of those rows the list shows before it scrolls the rest. */
+export declare const DATA_TYPE_HINT_MAX_ROWS = 10;
 export declare const HEADER_ICON_HEIGHT = 12;
 export declare const HEADER_ICON_MARGIN_BOTTOM = 4;
 export declare const TABLE_BORDER = 1;
 export declare const TABLE_PADDING = 8;
 export declare const TABLE_HEADER_PADDING = 2;
-export declare const TABLE_HEADER_ICON_MARGIN_BOTTOM = 2;
 export declare const TABLE_HEADER_INPUT_HEIGHT: number;
+/** The room a table's header band keeps above and below its input line. */
+export declare const TABLE_HEADER_BAND_PADDING = 2;
+/**
+ * What a table's header adds under the card's top padding. The band starts at
+ * the top border instead, over that padding: one input line and its own room,
+ * a little taller than a row, holding the add column and remove buttons too.
+ */
 export declare const TABLE_HEADER_HEIGHT: number;
 export declare const TABLE_HEADER_BUTTON_MARGIN_LEFT = 4;
+/** How wide the colour a table wears along its left edge is drawn. */
+export declare const TABLE_COLOR_WIDTH = 4;
+/** The strip the two header buttons take along the right end of the header line. */
+export declare const TABLE_HEADER_BUTTONS_WIDTH: number;
 export declare const COLUMN_DELETE_WIDTH = 12;
 export declare const COLUMN_KEY_WIDTH = 12;
+/** The table icon before the name, at the key badge's size so the two stand in one column. */
+export declare const TABLE_HEADER_ICON_SIZE = 12;
+/** The gap after that icon, the one a key badge keeps, which lines the name up with the column names. */
+export declare const TABLE_HEADER_ICON_GAP = 8;
+/** Where the name starts along the header line, past that icon and its gap. */
+export declare const TABLE_HEADER_NAME_X: number;
 export declare const COLUMN_MIN_WIDTH = 60;
 export declare const COLUMN_NOT_NULL_WIDTH = 35;
 export declare const COLUMN_UNIQUE_WIDTH = 22;
@@ -29,6 +54,8 @@ export declare const COLUMN_HEIGHT: number;
 export declare const VIEW_TABLE_HEADER_ICON_SIZE = 16;
 /** The gap between that icon and the name, the reference's one unit of spacing. */
 export declare const VIEW_TABLE_HEADER_ICON_GAP = 4;
+/** Where a view card's name starts along its header line, past that icon and gap. */
+export declare const VIEW_TABLE_HEADER_NAME_X: number;
 /** The size a view card draws its header name at, over the size its rows take. */
 export declare const VIEW_TABLE_HEADER_FONT_SIZE = 14;
 /**
@@ -43,11 +70,7 @@ export declare const VIEW_TABLE_HEADER_FONT_SCALE: number;
  * of its own synthesises one wider still, so the slot carries the room for both.
  */
 export declare const VIEW_TABLE_HEADER_WEIGHT_SCALE = 1.04;
-/**
- * The header a view card draws: the icon line with the card's own padding under
- * it, and none of the icon band the document header keeps above the name,
- * because a view offers no edit affordance there.
- */
+/** The header a view card draws: the icon line with the card's own padding under it. */
 export declare const VIEW_TABLE_HEADER_HEIGHT: number;
 /** The key badge a view row draws, at the size the reference gives a row icon. */
 export declare const VIEW_COLUMN_ICON_SIZE = 16;

package/dist/engine/index.js

@@ -1,16 +1,16 @@
-import { In as e, X as t, Yt as n, _ as r, _i as i, dn as a, h as o, n as s, qi as c, r as l, t as u, u as d, x as f } from "../schemaGCService-CXVjeF9p.js";
+import { $i as e, Ln as t, Xt as n, Z as r, _ as i, fn as a, h as o, n as s, r as c, t as l, u, x as d, xi as f } from "../schemaGCService-CFiz1xOG.js";
 import { isEmpty as p } from "es-toolkit/compat";
 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 = r(b), C = d(S, !1);
+	let x = /* @__PURE__ */ new Set(), S = i(b), C = u(S, !1);
 	C.dispatchSync(a({
 		width: 0,
 		height: 0
 	}));
-	let w = l(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(o(f), _(200)), D = /* @__PURE__ */ new Set(), O = new u(), k = (e) => (D.has(e) || D.add(e), () => {
+	let w = c(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(o(d), _(200)), D = /* @__PURE__ */ new Set(), O = new l(), k = (e) => (D.has(e) || D.add(e), () => {
 		D.delete(e);
 	}), A = (e, t) => {
 		D.forEach((r) => {
@@ -18,16 +18,16 @@ function b(b) {
 			n(i, t);
 		});
 	}, j = (n) => {
-		let r = i(n);
-		C.dispatchSync(t(p(r) ? "{}" : r)), O.run(c(C.state)).then((t) => {
-			(t.tableIds.length || t.tableColumnIds.length || t.relationshipIds.length || t.indexIds.length || t.indexColumnIds.length || t.memoIds.length) && (s(C.state, t), C.dispatchSync(e()));
+		let i = f(n);
+		C.dispatchSync(r(p(i) ? "{}" : i)), O.run(e(C.state)).then((e) => {
+			(e.tableIds.length || e.tableColumnIds.length || e.relationshipIds.length || e.indexIds.length || e.indexColumnIds.length || e.memoIds.length) && (s(C.state, e), C.dispatchSync(t()));
 		});
 	}, M = (e) => {
 		T.next([e].flat());
 	};
-	return x.add(E.subscribe(() => A(y.change, void 0))).add(T.pipe(o(f), v((e) => e.map((e) => m(e, ["tags"])))).subscribe(C.dispatchSync)), Object.freeze({
+	return x.add(E.subscribe(() => A(y.change, void 0))).add(T.pipe(o(d), v((e) => e.map((e) => m(e, ["tags"])))).subscribe(C.dispatchSync)), Object.freeze({
 		get value() {
-			return c(C.state);
+			return e(C.state);
 		},
 		on: k,
 		setInitialValue: j,

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

@@ -37,7 +37,8 @@ export declare const loadSchemaGraphQLAction$: (value: string) => GeneratorActio
 export declare const loadSchemaDBMLAction$: (value: string) => GeneratorAction;
 export declare const loadSchemaAMLAction$: (value: string) => GeneratorAction;
 export declare const dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
-export declare const dragoverColumnAction$: (targetId: string, targetTableId: string) => GeneratorAction;
+/** A null targetId drops past the last row, which appends. */
+export declare const dragoverColumnAction$: (targetId: string | null, targetTableId: string) => GeneratorAction;
 export declare const columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;
 export declare const columnKeyHoverEndAction$: () => GeneratorAction;
 export declare const actions$: {
@@ -59,7 +60,7 @@ export declare const actions$: {
     loadSchemaDBMLAction$: (value: string) => GeneratorAction;
     loadSchemaAMLAction$: (value: string) => GeneratorAction;
     dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
-    dragoverColumnAction$: (targetId: string, targetTableId: string) => GeneratorAction;
+    dragoverColumnAction$: (targetId: string | null, targetTableId: string) => GeneratorAction;
     columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;
     columnKeyHoverEndAction$: () => GeneratorAction;
 };

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

@@ -1,8 +1,23 @@
 import { GeneratorAction } from '../../generator.actions';
+import { Point } from '../../../internal-types';
 import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
 /** The origin it adds the movement to is the one getMovementScrollTo solved against. */
 export declare const changeZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
 export declare const streamZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
+export type PinchZoom = {
+    /** The zoom the pinch has reached, which the store rounds as it lands. */
+    zoomLevel: number;
+    /** Where the pinch is centred now, in the scene box. */
+    screen: Point;
+    /** The scene point the pinch holds, else the one under screen. */
+    scene?: Point;
+};
+/**
+ * A step of a pinch: the zoom it has reached, with the scene point it holds put
+ * under where it is centred now, so two fingers zoom about their midpoint and
+ * pan as it travels. Streamed, so a whole pinch is one undo entry as a wheel is.
+ */
+export declare const pinchZoomAction$: ({ zoomLevel, screen, scene }: PinchZoom, source?: GeometrySource) => GeneratorAction;
 export declare const actions$: {
     changeZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
     streamZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;

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

@@ -7,6 +7,7 @@ export type RxStore = Store & {
     undo: () => void;
     redo: () => void;
     history: History;
+    resetHistory: () => void;
     change$: Observable<Array<AnyAction>>;
 };
 export type RxStoreOptions = {

package/dist/engine/tag.d.ts

@@ -4,6 +4,8 @@ export declare const Tag: {
     readonly shared: 1;
     readonly changeOnly: 2;
     readonly following: 4;
+    /** A step a pointer drag streams, where an undo of the same move is one jump. */
+    readonly drag: 8;
 };
 export declare function attachActionTag(tag: number, action: AnyAction): AnyAction;
 export declare function attachActionsTag(tag: number, actions: AnyAction[]): AnyAction[];