@dineug/erd-editor 3.9.2 → 4.0.0

package/dist/components/erd/Erd.d.ts

@@ -2,6 +2,10 @@ import { FC } from '@dineug/r-html';
 export type ErdProps = {
     isDarkMode: boolean;
     mouseTracking: boolean;
+    readonly: boolean;
+    enableWelcomeScreen?: boolean;
+    enableThemeBuilder?: boolean;
+    enableLocalePicker?: boolean;
 };
 declare const Erd: FC<ErdProps>;
 export default Erd;

package/dist/components/erd/automatic-table-placement/AutomaticTablePlacement.d.ts

@@ -1,5 +1,6 @@
 import { FC, Ref } from '@dineug/r-html';
 import { AppContext } from '../../appContext';
+import { I18n } from '../../../i18n/translate';
 export type AutomaticTablePlacementProps = {
     app: Ref<AppContext>;
     onChange: (tables: TablePoint[]) => void;
@@ -13,7 +14,7 @@ export type TablePoint = {
 export type PlacementToastState = {
     progress: number;
 };
-export declare function placementDescription({ progress, }: PlacementToastState): string;
+export declare function placementDescription({ progress }: PlacementToastState, i18n?: I18n): string;
 declare const AutomaticTablePlacement: FC<AutomaticTablePlacementProps>;
 export default AutomaticTablePlacement;
 //# sourceMappingURL=AutomaticTablePlacement.d.ts.map

package/dist/components/erd/automatic-table-placement/createAutomaticTablePlacement.d.ts

@@ -1,12 +1,43 @@
 import { RootState } from '../../../engine/state';
-import { Table } from '../../../internal-types';
-type Node = {
+import { Table, TableGroup } from '../../../internal-types';
+/** A table in no group, put at the node less its radius, as it always was. */
+type TableNode = {
     id: string;
     r: number;
     x: number;
     y: number;
+    vx: number;
+    vy: number;
     ref: Table;
+    width: number;
+    height: number;
 };
+/** A member, and where it stands from the corner of its group's box. */
+type Member = {
+    ref: Table;
+    dx: number;
+    dy: number;
+};
+/**
+ * A group with members, moved as one box centred on the node: the members keep
+ * where they stand inside it, and the box, their bounds and the padding, is
+ * the rect the group is drawn at, so a preview shows the group where it goes.
+ */
+type GroupNode = {
+    id: string;
+    r: number;
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    group: TableGroup;
+    width: number;
+    height: number;
+    members: Member[];
+};
+type Node = TableNode | GroupNode;
+/** The least room a group's box keeps from another group's box or a table. */
+export declare const GROUP_BOX_GAP = 100;
 /** The two readings of a simulation's heat that its progress is taken from. */
 type Cooling = {
     alpha(): number;
@@ -23,6 +54,11 @@ type Cooling = {
  * });
  */
 export declare function placementProgress(simulation: Cooling): number;
+/**
+ * The force simulation that places the tables, around the middle of what the
+ * document draws. A group with members is one box in it, its members kept
+ * inside and the box kept clear of the others, so it is drawn where it goes.
+ */
 export declare function createAutomaticTablePlacement(state: RootState): import('d3-force').Simulation<Node, undefined>;
 export {};
 //# sourceMappingURL=createAutomaticTablePlacement.d.ts.map

package/dist/components/erd/automatic-table-placement/elkPlacement.d.ts

@@ -0,0 +1,42 @@
+import { FC } from '@dineug/r-html';
+import { AppContext } from '../../appContext';
+import { ElkLayoutPoint, ElkLayoutRequest } from '../../../services/elk-layout';
+type PlacingToastProps = {
+    onCancel: () => void;
+};
+/**
+ * The message up while ELK works, and the whole of what a one-shot placement
+ * shows. There is no progress to follow and nothing to read off a layout that
+ * does not exist yet, so Cancel is the only thing on it. A view placement shows it too.
+ */
+export declare const PlacingToast: FC<PlacingToastProps>;
+/** How a layout ended: placed, given up on by whoever waited, or never answered. */
+export type ElkLayoutAnswer = {
+    status: 'placed';
+    points: ElkLayoutPoint[];
+} | {
+    status: 'cancelled';
+} | {
+    status: 'failed';
+    error: unknown;
+};
+export type LayoutByElkOptions = {
+    /**
+     * Whether the toast waits until the layout has run long enough to say so,
+     * for a placement nobody asked to watch, rather than going up at once.
+     */
+    whenSlow?: boolean;
+    /** Ends the wait from outside, as Cancel does, and takes the toast down. */
+    signal?: AbortSignal;
+};
+/**
+ * One ELK layout behind the Placing toast, reading nothing but the request and
+ * the app context, so the document and a document not loaded yet are placed
+ * alike. Cancel and the stop key end the wait at once, the toast with it.
+ *
+ * @example
+ * const answer = await layoutByElk(app, request, { whenSlow: true });
+ */
+export declare function layoutByElk({ emitter, shortcut$ }: AppContext, request: ElkLayoutRequest, { whenSlow, signal }?: LayoutByElkOptions): Promise<ElkLayoutAnswer>;
+export {};
+//# sourceMappingURL=elkPlacement.d.ts.map

package/dist/components/erd/automatic-table-placement/flowPlacement.d.ts

@@ -0,0 +1,21 @@
+import { AppContext } from '../../appContext';
+import { ElkLayoutPoint, ElkLayoutRequest } from '../../../services/elk-layout';
+/**
+ * What a Flow placement of a document asks ELK, measured on a plain store of
+ * its own with the editor's text measure, so nothing reaches the editor's
+ * store. Null under two tables or with no relationship, the grid's cases.
+ *
+ * @example
+ * const request = createFlowRequest(app, json);
+ */
+export declare function createFlowRequest({ toWidth }: AppContext, json: string): ElkLayoutRequest | null;
+/**
+ * Where each table of a document not loaded yet goes by Flow, measured from
+ * the corner of the block the tables make, so the caller decides where that
+ * block stands. Null leaves the tables to the grid, and says nothing of why.
+ *
+ * @example
+ * const points = await placeByFlow(app, json, controller.signal);
+ */
+export declare function placeByFlow(app: AppContext, json: string, signal?: AbortSignal): Promise<ElkLayoutPoint[] | null>;
+//# sourceMappingURL=flowPlacement.d.ts.map

package/dist/components/erd/automatic-table-placement/placementActions.d.ts

@@ -0,0 +1,14 @@
+import { AnyAction } from '@dineug/r-html';
+import { RootState } from '../../../engine/state';
+import { TableMove } from '../../../konva/scene/contentBounds';
+import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
+/**
+ * What a placement lands as: each table at its point, each group with members
+ * at the rect round where they land, and the view centred on the box all of it
+ * fills, read before the move. Dispatched together, they are one undo entry.
+ *
+ * @example
+ * store.dispatch(toPlacementActions(store.state, points));
+ */
+export declare function toPlacementActions(state: RootState, tables: ReadonlyArray<TableMove>, source?: GeometrySource): AnyAction[];
+//# sourceMappingURL=placementActions.d.ts.map

package/dist/components/erd/automatic-table-placement/runElkPlacement.d.ts

@@ -1,15 +1,5 @@
-import { FC } from '@dineug/r-html';
 import { AppContext } from '../../appContext';
 import { ElkLayoutPoint, ElkPlacement } from '../../../services/elk-layout';
-type PlacingToastProps = {
-    onCancel: () => void;
-};
-/**
- * The message up while ELK works, and the whole of what a one-shot placement
- * shows. There is no progress to follow and nothing to read off a layout that
- * does not exist yet, so Cancel is the only thing on it. A view placement shows it too.
- */
-export declare const PlacingToast: FC<PlacingToastProps>;
 /**
  * Places every table by ELK and hands the layout straight over. No preview
  * overlay: one layout arrives at once, there is nothing to weigh before it
@@ -19,5 +9,4 @@ export declare const PlacingToast: FC<PlacingToastProps>;
  * runElkPlacement(app.value, placement, handleChangeAutomaticTablePlacement);
  */
 export declare function runElkPlacement(app: AppContext, placement: ElkPlacement, onChange: (tables: ElkLayoutPoint[]) => void): Promise<void>;
-export {};
 //# sourceMappingURL=runElkPlacement.d.ts.map

package/dist/components/erd/canvas/SceneIcon.template.d.ts

@@ -15,8 +15,8 @@ export type SceneIconOptions = {
 };
 /**
  * A lucide icon drawn at size, by scaling its own 24 unit box. The scale carries
- * the stroke with it, which is what keeps the weight the same as the svg the DOM
- * scene rendered at that size.
+ * the stroke with it, which keeps the weight of the svg the DOM scene drew, and
+ * a click answers the main button alone (mainButtonClick).
  */
 export declare function sceneIcon({ icon, name, kind, size, color, x, y, click, mouseenter, mouseleave, }: SceneIconOptions): DOMTemplateLiterals | null;
 //# sourceMappingURL=SceneIcon.template.d.ts.map

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

@@ -1,8 +1,24 @@
+import { HeldTableGroupBoxes } from '../../../engine/modules/table-group/generator.actions';
 import { RootState } from '../../../engine/state';
 import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
-/** Raises the flag and holds the scene's view as it stands until endEntityDrag. */
+/**
+ * Raises the flag, holds the scene's view as it stands until endEntityDrag,
+ * and, in the document while groups show, the box each group shows.
+ */
 export declare function beginEntityDrag(root: RootState, source?: GeometrySource): void;
 export declare function endEntityDrag(root: RootState, source?: GeometrySource): void;
 /** Reads the flag through the observable, so a scene render tracks it. */
 export declare function isEntityDragActive(root: RootState, source?: GeometrySource): boolean;
+/**
+ * Marks the drag as past the click distance from its press, after which its
+ * drop is judged and a drop target shown: a tremor short of it changes no group.
+ */
+export declare function markEntityDragTravelled(root: RootState, source?: GeometrySource): void;
+/** Whether the drag the scene holds has travelled the click distance, tracked as the flag is. */
+export declare function hasEntityDragTravelled(root: RootState, source?: GeometrySource): boolean;
+/**
+ * The box each group showed as the scene's drag began, or null while no drag
+ * holds it: what a group the drag leaves standing is drawn and judged in.
+ */
+export declare function getHeldTableGroupBoxes(root: RootState, source?: GeometrySource): HeldTableGroupBoxes | null;
 //# sourceMappingURL=entityDrag.d.ts.map

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

@@ -0,0 +1,11 @@
+import { DragMove } from '../../../utils/globalEventObservable';
+/**
+ * Takes a middle press anywhere in a stage container as a pan, heard in the
+ * capture phase before konva or the scene root, and prevents its lift wherever
+ * it lands: nothing selects, drags or clicks, and nothing autoscrolls or pastes.
+ *
+ * @example
+ * addUnsubscribe(listenMiddleButtonPan(container, handleMove, handlePress));
+ */
+export declare function listenMiddleButtonPan(container: HTMLElement, onMove: (move: DragMove) => void, onPress?: () => void): () => void;
+//# sourceMappingURL=middleButtonPan.d.ts.map

package/dist/components/erd/canvas/relationship-group/relationship/Relationship.d.ts

@@ -5,6 +5,8 @@ export type RelationshipProps = {
     strokeWidth: number;
     /** Whether the view lights this connector, decided by the scene it is drawn in. */
     lit?: boolean;
+    /** Told as the pointer comes onto the connector and leaves it, for its label to light along. */
+    onHover?: (id: string, hover: boolean) => void;
 };
 declare const Relationship: FC<RelationshipProps>;
 export default Relationship;

package/dist/components/erd/canvas/relationship-group/relationship/RelationshipActionLabel.d.ts

@@ -0,0 +1,32 @@
+import { FC } from '@dineug/r-html';
+import { Relationship } from '../../../../../internal-types';
+import { Anchor } from '../../../../../utils/draw-relationship';
+/** The size the referential action label is drawn at, in scene units. */
+export declare const ACTION_LABEL_FONT_SIZE = 10;
+type LabelBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * The box the label fills beside the child end: over a route leaving sideways,
+ * reaching away from the table, and right of one leaving up or down. Across, it
+ * clears the widest marker, so no stroke of a crow's foot runs under it.
+ */
+export declare function actionLabelBox(end: Anchor, text: string): LabelBox;
+export type RelationshipActionLabelProps = {
+    relationship: Relationship;
+    /** The connector the pointer rests on, whose label lights with it. */
+    hovered?: {
+        id: string;
+    };
+};
+/**
+ * The ON DELETE and ON UPDATE a connector sets, at its child end, on a box of
+ * the canvas colour. The group draws every label after every route, so another
+ * connector crossing one runs under the box rather than through the text.
+ */
+declare const RelationshipActionLabel: FC<RelationshipActionLabelProps>;
+export default RelationshipActionLabel;
+//# sourceMappingURL=RelationshipActionLabel.d.ts.map

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

@@ -3,6 +3,15 @@ import { KonvaEventObject } from 'konva/lib/Node';
 export type SceneMouseEvent = KonvaEventObject<MouseEvent>;
 export type SceneTouchEvent = KonvaEventObject<TouchEvent>;
 export type ScenePointerEvent = SceneMouseEvent | SceneTouchEvent;
+/**
+ * The click listener of a scene button, which acts on the main button alone:
+ * konva makes a click of any button's press and lift, and a right click is the
+ * context menu's. A Mac control click is the main button, so it still acts.
+ *
+ * @example
+ * on:click={mainButtonClick(handleRemove)}
+ */
+export declare const mainButtonClick: (click: (event: SceneMouseEvent) => void) => (event: SceneMouseEvent) => void;
 /**
  * The face utils/text.ts measures a string with. Drawing in anything else would
  * make a cell wider or narrower than the width the layout reserved for it.
@@ -78,6 +87,22 @@ export declare const DOCUMENT_CARD_SHADOW_OFFSET_Y = 2;
  */
 export declare const VIEW_CARD_GLOW_BLUR = 14;
 export declare const VIEW_CARD_GLOW_OPACITY = 0.55;
+/**
+ * How much of its color a table group's body shows, the canvas and the
+ * connectors over it reading through.
+ */
+export declare const TABLE_GROUP_FILL_OPACITY = 0.12;
+/** The radius a table group's box is rounded with, a table's own. */
+export declare const TABLE_GROUP_CORNER_RADIUS = 6;
+/** The room a table group's name keeps from each end of its title bar, the name editor's too. */
+export declare const TABLE_GROUP_TITLE_PADDING = 8;
+/** The weight a table group's name is drawn and edited at, a heading over the tables' own names. */
+export declare const TABLE_GROUP_TITLE_FONT_WEIGHT = "bold";
+/**
+ * The line a table drag outlines the group its drop would join with, twice
+ * the box's own line so it reads apart from the selection.
+ */
+export declare const TABLE_GROUP_DROP_WIDTH = 2;
 /** The side of the square viewBox every icon is authored in. */
 export declare const ICON_VIEW_SIZE: number;
 /** What a colour is when the scene paints nothing, as a CSS keyword konva takes. */
@@ -108,6 +133,19 @@ export declare const CURSOR_INHERIT = "";
  * on:mouseenter={(event) => setSceneCursor(event, CURSOR_POINTER)}
  */
 export declare function setSceneCursor(event: ScenePointerEvent, cursor: string): void;
+/**
+ * The cursors one scene component asks for, so a node unmounted from under the pointer, which konva
+ * sends no leave for, hands the container back the cursor it took: release writes CURSOR_INHERIT
+ * once, unless the last cursor the component asked for already was.
+ *
+ * @example
+ * const cursor = createSceneCursorScope();
+ * onUnmounted(cursor.release);
+ */
+export declare function createSceneCursorScope(): {
+    set(event: ScenePointerEvent, cursor: string): void;
+    release(): 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

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

@@ -2,7 +2,10 @@ import { FC } from '@dineug/r-html';
 import { Table } from '../../../../internal-types';
 export type TableProps = {
     table: Table;
-    /** A drawn copy rather than the table itself, so nothing in it takes an id. */
+    /**
+     * A drawn copy rather than the table itself, so nothing in it takes an id,
+     * and no group color either: a copy, a duplicate's, lands in no group.
+     */
     preview?: boolean;
     hovered?: boolean;
     hoveredColumnId?: string | null;
@@ -17,6 +20,11 @@ export type TableProps = {
      * by the scene, which walks the document's links once for every card it draws.
      */
     relatedColumnIds?: Set<string> | null;
+    /**
+     * The group whose color the header wears, '' for none, named by a scene that
+     * reads the group list once for every table; a table drawn alone reads its own.
+     */
+    tableGroupId?: string;
 };
 declare const Table: FC<TableProps>;
 export default Table;

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

@@ -77,6 +77,17 @@ export declare function getCellTextBaseline(fontFamily?: string): number;
 export declare function getCellTextHeight(fontFamily?: string): number;
 /** Where a column row's cells start, past the key badge its own source sizes. */
 export declare function getColumnCellsX(source?: GeometrySource): number;
+/**
+ * Where a document row's alternate key mark starts: one margin past the last
+ * of the cells given, whatever order the settings put them in. The mark is
+ * derived, so it is no cell of that order and nothing focuses, edits or moves it.
+ */
+export declare function getAlternateKeyMarkX(slots: ColumnCellSlot[]): number;
+/**
+ * The box the mark's code face line is centred in, so it stands on the text
+ * face's baseline, the one the cell before it is drawn on, and not on its own.
+ */
+export declare function getAlternateKeyMarkHeight(): 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;
 /**

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

@@ -45,6 +45,13 @@ export type ColumnProps = {
     widthDataType: number;
     widthDefault: number;
     widthComment: number;
+    /**
+     * The room the table keeps for alternate key marks after the last cell, 0
+     * while it draws none; the same for every row, so the marks stay in line.
+     */
+    widthAlternateKey?: number;
+    /** The mark this row carries in that room, AK1.2 or several comma joined. */
+    alternateKey?: string;
     focusName: boolean;
     focusDataType: boolean;
     focusNotNull: boolean;

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

@@ -1,10 +1,9 @@
 import { SceneMouseEvent } from '../sceneTokens';
-import { FocusType } from '../../../../engine/modules/editor/state';
 export type DoubleClickGuard = {
-    /** Records the cell a click opened a pair on. */
-    track(cell: FocusType, event: SceneMouseEvent): void;
+    /** Records the cell, or a group's part, a click opened a pair on. */
+    track(cell: string, event: SceneMouseEvent): void;
     /** Whether a konva dblclick closes a pair that began on this same cell. */
-    isDouble(cell: FocusType, event: SceneMouseEvent): boolean;
+    isDouble(cell: string, event: SceneMouseEvent): boolean;
 };
 /**
  * Tells a real double click from the one konva invents. Konva fires dblclick on

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

@@ -1,15 +1,8 @@
-import { GeneratorAction } from '../../../../engine/generator.actions';
 import { RxStore } from '../../../../engine/rx-store';
 /**
- * Stands the reader on one table in the document, selected, scrolled to the
- * middle of the screen at the document's own zoom unless it is already on
- * screen whole, since that scroll is the one change the host hears of. One that is gone is passed over.
- */
-export declare const showErdTableAction$: (tableId: string) => GeneratorAction;
-/**
- * The Go to ERD button's whole errand: the tab in one dispatch, the scroll and
- * the selection in a second. A batch is classified by the state before it, so
- * a scroll travelling with the tab change would be redirected into the view it leaves.
+ * The Go to ERD button's whole errand, a jump from outside the canvas like any
+ * other: the tab in one dispatch, then the scroll and the selection, which
+ * never starts or finishes a relationship being drawn.
  *
  * @example
  * goToErdTable(store, 'orders');

package/dist/components/erd/canvas/table-group/TableGroup.d.ts

@@ -0,0 +1,17 @@
+import { FC } from '@dineug/r-html';
+import { TableGroupLinks } from './tableGroupBox';
+import { Table, TableGroup } from '../../../../internal-types';
+export type TableGroupProps = {
+    group: TableGroup;
+    /** The group's member tables, read once for every group by TableGroups. */
+    members: ReadonlyArray<Table>;
+    links: TableGroupLinks;
+};
+/**
+ * A group's frame over its body (TableGroupBody), in getDrawnTableGroupRect's box: a title bar with
+ * the group icon, the name and the remove button, one line around the box, the peer ring and the
+ * sashes, in the theme's group colors with no color it reads.
+ */
+declare const TableGroup: FC<TableGroupProps>;
+export default TableGroup;
+//# sourceMappingURL=TableGroup.d.ts.map

package/dist/components/erd/canvas/table-group/TableGroupBody.d.ts

@@ -0,0 +1,17 @@
+import { FC } from '@dineug/r-html';
+import { TableGroupLinks } from './tableGroupBox';
+import { Table, TableGroup } from '../../../../internal-types';
+export type TableGroupBodyProps = {
+    group: TableGroup;
+    /** The group's member tables, read once for every group by TableGroups. */
+    members: ReadonlyArray<Table>;
+    links: TableGroupLinks;
+};
+/**
+ * A group's body under its bar, in its color at a low alpha or the theme's group body (alpha its own),
+ * drawn before every frame, so no body stands over another group's bar. The main button reads it as
+ * the canvas under it, so only another button selects the group there, for the menu it opens.
+ */
+declare const TableGroupBody: FC<TableGroupBodyProps>;
+export default TableGroupBody;
+//# sourceMappingURL=TableGroupBody.d.ts.map

package/dist/components/erd/canvas/table-group/TableGroupDropTarget.d.ts

@@ -0,0 +1,10 @@
+import { FC } from '@dineug/r-html';
+export type TableGroupDropTargetProps = {};
+/**
+ * The outline of each group a table drag would drop a table into, in the focus color, over the
+ * static scene and under the dragged tables, in the box the drop is judged in; nothing where the
+ * drop would put every table in none, nor short of the click distance, where it judges none.
+ */
+declare const TableGroupDropTarget: FC<TableGroupDropTargetProps>;
+export default TableGroupDropTarget;
+//# sourceMappingURL=TableGroupDropTarget.d.ts.map

package/dist/components/erd/canvas/table-group/TableGroupSash.d.ts

@@ -0,0 +1,35 @@
+import { FC } from '@dineug/r-html';
+import { TableGroup, ValuesType } from '../../../../internal-types';
+import { Rect } from '../../../../konva/scene/metrics';
+export declare const TableGroupSashPosition: {
+    readonly left: "left";
+    readonly right: "right";
+    readonly top: "top";
+    readonly bottom: "bottom";
+    readonly lt: "lt";
+    readonly rt: "rt";
+    readonly lb: "lb";
+    readonly rb: "rb";
+};
+export type TableGroupSashPosition = ValuesType<typeof TableGroupSashPosition>;
+/**
+ * The box a sash drag leaves, the edges it grabs moved by the drag in scene
+ * units: never smaller than the minimum, nor than the members' padded box,
+ * which the edge stops at however far past it the pointer goes.
+ */
+export declare function resizeTableGroupRect(start: Rect, members: Rect | null, position: TableGroupSashPosition, movementX: number, movementY: number): Rect;
+export type TableGroupSashProps = {
+    group: TableGroup;
+    /** The box the group is drawn in, in scene units; the sashes sit on its edges. */
+    box: Rect;
+    /** Takes each step's box to draw, and null once the drag is over. */
+    onDraft: (rect: Rect | null) => void;
+};
+/**
+ * The eight resize handles on a group's edges and corners, selected or not, as a memo's are. A drag
+ * draws its steps without writing them and writes one resize as it ends, so
+ * peers hear one write and one undo puts back the rect it started from.
+ */
+declare const TableGroupSash: FC<TableGroupSashProps>;
+export default TableGroupSash;
+//# sourceMappingURL=TableGroupSash.d.ts.map

package/dist/components/erd/canvas/table-group/TableGroups.d.ts

@@ -0,0 +1,10 @@
+import { FC } from '@dineug/r-html';
+export type TableGroupsProps = {};
+/**
+ * The document's groups by zIndex in two passes, every body before every frame, so a group's bar
+ * and sashes stand over every body: a large group drawn over a smaller one it holds leaves the
+ * inner bar to its own group. A scene mounts it while groups show; it reads the list itself.
+ */
+declare const TableGroups: FC<TableGroupsProps>;
+export default TableGroups;
+//# sourceMappingURL=TableGroups.d.ts.map

package/dist/components/erd/canvas/table-group/tableGroupBox.d.ts

@@ -0,0 +1,40 @@
+import { DoubleClickGuard } from '../table/doubleClick';
+import { RootState } from '../../../../engine/state';
+import { Table, TableGroup } from '../../../../internal-types';
+import { Rect } from '../../../../konva/scene/metrics';
+import { GeometrySource } from '../../../../utils/draw-relationship/geometrySource';
+/**
+ * The box a group is drawn in, on the canvas and the minimap: getTableGroupRect's, and while a drag
+ * holds the scene and leaves the group standing, the box it held as the drag began with the members
+ * left standing, so it neither shrinks under a member lifted out nor stretches after one carried off.
+ *
+ * @example
+ * const box = getDrawnTableGroupRect(state, group, source, members);
+ */
+export declare function getDrawnTableGroupRect(state: RootState, group: TableGroup, source: GeometrySource, members: ReadonlyArray<Table>): Rect;
+/** The two nodes a group draws apart, each telling the other whether the pointer is over it. */
+export type TableGroupHoverPart = 'frame' | 'body';
+/**
+ * What a group's body and its frame share, drawn apart in TableGroups' two passes: the box a sash
+ * drag draws until its one resize, the guard telling a double click on the bar from a pair begun on
+ * the body, and whether the pointer is over either, which shows the remove button.
+ */
+export type TableGroupLinks = {
+    draftOf(groupId: string): Rect | null;
+    setDraft(groupId: string, rect: Rect | null): void;
+    guardOf(groupId: string): DoubleClickGuard;
+    isHovered(groupId: string): boolean;
+    setHover(groupId: string, part: TableGroupHoverPart, hovered: boolean): void;
+};
+export declare function createTableGroupLinks(): TableGroupLinks;
+/**
+ * Reads each group's members off one walk over the tables, handing a group the
+ * list it had last time while no member came or went, so a scene render that
+ * moved no membership leaves every group component's props as they were.
+ *
+ * @example
+ * const membersOf = memberLists(state);
+ * membersOf(group.id);
+ */
+export declare function createTableGroupMemberLists(): (state: RootState) => (groupId: string) => ReadonlyArray<Table>;
+//# sourceMappingURL=tableGroupBox.d.ts.map

package/dist/components/erd/canvas/table-group/titleLayout.d.ts

@@ -0,0 +1,45 @@
+/** The group icon before the name, at the table header icon's size and gap. */
+export declare const TABLE_GROUP_ICON_SIZE = 12;
+/** Where the name starts along the title bar, past the icon and its gap. */
+export declare const TABLE_GROUP_NAME_X: number;
+/** The remove button at the end of the bar, at the size of a table header's. */
+export declare const TABLE_GROUP_REMOVE_SIZE = 12;
+/**
+ * The box a group's name is centred in, down from the top of its title bar on
+ * a whole pixel. The scene hands konva this box with verticalAlign middle and
+ * the name editor gives its input the same one, so the two baselines meet.
+ *
+ * @example
+ * const { x, y, width, height } = getTableGroupNameBox(box.width);
+ */
+export declare function getTableGroupNameBox(barWidth?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Where the group icon stands on the title bar: the bar's padding in, centred
+ * down the bar on a whole pixel, as the table header centres its icon.
+ *
+ * @example
+ * const { x, y, size } = getTableGroupIconBox();
+ */
+export declare function getTableGroupIconBox(): {
+    x: number;
+    y: number;
+    size: number;
+};
+/**
+ * Where the remove button stands on the title bar: the bar's padding short of
+ * its end, centred down the bar on a whole pixel, as the group icon is.
+ *
+ * @example
+ * const { x, y, size } = getTableGroupRemoveBox(box.width);
+ */
+export declare function getTableGroupRemoveBox(barWidth: number): {
+    x: number;
+    y: number;
+    size: number;
+};
+//# sourceMappingURL=titleLayout.d.ts.map

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

@@ -20,6 +20,8 @@ export type MoveEntityOptions = {
      * again here, so a leaf pays for one context subscription and not two.
      */
     source: Ref<GeometrySource>;
+    /** Read at the press: false leaves it a selection that lifts nothing. */
+    canMove?: () => boolean;
 };
 /**
  * The pointer start every draggable entity shares: select it, hand an Alt drag

package/dist/components/erd/draw-target/DrawTargetButtons.d.ts

@@ -0,0 +1,16 @@
+import { FC, Ref } from '@dineug/r-html';
+import { PillSize } from './placePill';
+export type DrawTargetButtonsProps = {
+    root: Ref<HTMLDivElement>;
+    readonly: boolean;
+};
+/** The pill at the size the stylesheet gives it: two buttons, the gap and the padding. */
+export declare const PILL_SIZE: PillSize;
+/**
+ * The two buttons beside the table a relationship is drawn to: one maps the
+ * parent's key to columns the child already has, the other adds new ones as a
+ * press on the table does. A layer of the document canvas, never of a view.
+ */
+declare const DrawTargetButtons: FC<DrawTargetButtonsProps>;
+export default DrawTargetButtons;
+//# sourceMappingURL=DrawTargetButtons.d.ts.map