@dineug/erd-editor 3.4.0 → 3.6.0

package/dist/components/erd/canvas/shared-mouse-tracker/SharedMouseTracker.d.ts

@@ -1,4 +1,6 @@
 import { FC } from '@dineug/r-html';
 export type SharedMouseTrackerProps = {};
+/** One cursor per peer sharing a pointer, on the presence layer. */
 declare const SharedMouseTracker: FC<SharedMouseTrackerProps>;
 export default SharedMouseTracker;
+//# sourceMappingURL=SharedMouseTracker.d.ts.map

package/dist/components/erd/canvas/shared-mouse-tracker/shared-mouse-cursor/SharedMouseCursor.d.ts

@@ -3,5 +3,11 @@ import { SharedMouseTracker } from '../../../../../engine/modules/editor/state';
 export type SharedMouseCursorProps = {
     tracker: SharedMouseTracker;
 };
+/**
+ * One peer's pointer and nickname, eased toward the position they last shared.
+ * The colour identifies the editor rather than the theme, so it comes from the
+ * shared palette instead of a resolved token.
+ */
 declare const SharedMouseCursor: FC<SharedMouseCursorProps>;
 export default SharedMouseCursor;
+//# sourceMappingURL=SharedMouseCursor.d.ts.map

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

@@ -2,6 +2,15 @@ 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. */
+    preview?: boolean;
+    hovered?: boolean;
+    hoveredColumnId?: string | null;
+    ghostColumnId?: string | null;
+    editorFocused?: boolean;
+    /** Off while the table is kept built but scrolled out of the culling rect. */
+    visible?: boolean;
 };
 declare const Table: FC<TableProps>;
 export default Table;
+//# sourceMappingURL=Table.d.ts.map

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

@@ -0,0 +1,64 @@
+import { FocusType } from '../../../../engine/modules/editor/state';
+import { RootState } from '../../../../engine/state';
+import { Table } from '../../../../internal-types';
+import { Theme } from '../../../../themes/tokens';
+import { ColumnWidth } from '../../../../utils/calcTable';
+/** The four widths a column row measures from its table; the rest are fixed. */
+export type ColumnCellWidths = Pick<ColumnWidth, 'comment' | 'dataType' | 'default' | 'name'>;
+/** One editable box on a table, positioned inside the table's own group. */
+export type CellSlot = {
+    focusType: FocusType;
+    x: number;
+    width: number;
+};
+export type ColumnCellSlot = CellSlot & {
+    columnType: number;
+};
+/** Where the header cell row starts inside a table group. */
+export declare const HEADER_CELLS_X: number;
+export declare const HEADER_CELLS_Y: number;
+/** The text line inside a header cell and inside a column cell. */
+export declare const HEADER_TEXT_Y = 2;
+export declare const COLUMN_TEXT_Y = 2;
+/** Where the scene runs its focus rect inside a cell, header and column both. */
+export declare const CELL_UNDERLINE_Y: number;
+/**
+ * The paint that focus rect takes, header and column both: the input colour
+ * while the cell is being edited, and greyed out with the rest of the focus
+ * while the editor is not the one holding the keyboard.
+ */
+export declare function focusBorderFill(theme: Theme, edit: boolean, editorFocused: boolean | undefined): string;
+/**
+ * The baseline one line of cell text is drawn on, down from the top of the
+ * cell. Blink puts a painted baseline on the device grid before the zoom scales
+ * it, so only a whole pixel survives both rasterisers unchanged.
+ *
+ * @example
+ * const baseline = getCellTextBaseline();
+ */
+export declare function getCellTextBaseline(): number;
+/**
+ * The box one line of cell text is centred in. The scene hands konva this
+ * height with verticalAlign middle and the editor gives its input the same one,
+ * which is what puts the two baselines on one whole pixel instead of two.
+ *
+ * @example
+ * const height = getCellTextHeight();
+ */
+export declare function getCellTextHeight(): number;
+/** Where a column row's cells start, past the key badge. */
+export declare const COLUMN_CELLS_X: 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.
+ */
+export declare function getHeaderCellSlots(state: RootState, table: Table): CellSlot[];
+/**
+ * The cells of one column row, in the order the settings put them and at the x
+ * each lands on once the ones before it have taken their width.
+ */
+export declare function getColumnCellSlots(state: RootState, widths: ColumnCellWidths): ColumnCellSlot[];
+//# sourceMappingURL=cellLayout.d.ts.map

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

@@ -1,9 +1,10 @@
-import { FC, Ref } from '@dineug/r-html';
-import { AppContext } from '../../../../appContext';
+import { FC } from '@dineug/r-html';
+import { SceneMouseEvent } from '../../sceneTokens';
 import { Column } from '../../../../../internal-types';
 export type ColumnProps = {
-    app: Ref<AppContext>;
     column: Column;
+    y: number;
+    width: number;
     selected: boolean;
     widthName: number;
     widthDataType: number;
@@ -27,10 +28,20 @@ export type ColumnProps = {
     editDataType: boolean;
     editDefault: boolean;
     editComment: boolean;
-    draggable?: boolean;
+    hovered?: boolean;
+    /** The placeholder row for a column dragged in from another table. */
     ghost?: boolean;
-    onDragstart?: (event: DragEvent) => void;
-    onDragend?: (event: DragEvent) => void;
+    /** Drawn inside a copy of the table, which owns none of its ids. */
+    preview?: boolean;
+    editorFocused?: boolean;
+    /**
+     * The one pair of callbacks the scene keeps. A drop lands between siblings,
+     * so the table that owns the order is the only thing that can judge one, and
+     * the row can only say that a drag of it started and that it ended.
+     */
+    onDragstart?: (columnId: string, event: SceneMouseEvent) => void;
+    onDragend?: () => void;
 };
 declare const Column: FC<ColumnProps>;
 export default Column;
+//# sourceMappingURL=Column.d.ts.map

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

@@ -0,0 +1,15 @@
+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;
+    /** Whether a konva dblclick closes a pair that began on this same cell. */
+    isDouble(cell: FocusType, event: SceneMouseEvent): boolean;
+};
+/**
+ * Tells a real double click from the one konva invents. Konva fires dblclick on
+ * whatever the second click of any pair inside its window lands on, wherever
+ * the first one was, so the cell that opened the pair is remembered here.
+ */
+export declare function createDoubleClickGuard(): DoubleClickGuard;
+//# sourceMappingURL=doubleClick.d.ts.map

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

@@ -5,3 +5,4 @@ export declare function useFocusTable(ctx: Ctx, tableId: string): {
     hasEdit: (focusType: FocusType, columnId?: string) => boolean;
     hasSelectColumn: (columnId: string) => boolean;
 };
+//# sourceMappingURL=useFocusTable.d.ts.map

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

@@ -2,5 +2,6 @@ import { Ctx, Table } from '../../../../internal-types';
 export declare function useMoveTable(ctx: Ctx, props: {
     table: Table;
 }): {
-    onMoveStart: (event: MouseEvent | TouchEvent) => void;
+    onMoveStart: (event: import('../sceneTokens').ScenePointerEvent) => void;
 };
+//# sourceMappingURL=useMoveTable.d.ts.map

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

@@ -4,3 +4,4 @@ export declare function useSharedFocusTable(ctx: Ctx, tableId: string): {
     sharedFocusTableColor: () => string | null;
     sharedFocusColor: (focusType: FocusType, columnId?: string) => string | null;
 };
+//# sourceMappingURL=useSharedFocusTable.d.ts.map

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

@@ -0,0 +1,19 @@
+import { ScenePointerEvent } from './sceneTokens';
+import { SelectType } from '../../../engine/modules/editor/state';
+import { Ctx } from '../../../internal-types';
+export type MoveEntityOptions = {
+    /** Read late, because repeat hands a component a new entity in place. */
+    entityId: () => string;
+    selectType: SelectType;
+    /** The scene kinds a drag never starts from, as closest read their classes. */
+    blockedKinds: readonly string[];
+};
+/**
+ * The pointer start every draggable entity shares: select it, hand an Alt drag
+ * to the duplicate ghost, and otherwise move the whole selection with the
+ * pointer. Only the entity kind and the blocked areas differ between them.
+ */
+export declare function useMoveEntity(ctx: Ctx, options: MoveEntityOptions): {
+    onMoveStart: (event: ScenePointerEvent) => void;
+};
+//# sourceMappingURL=useMoveEntity.d.ts.map

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

@@ -2,3 +2,4 @@ import { Ctx } from '../../../internal-types';
 export declare function useSharedSelectEntity(ctx: Ctx, entityId: string): {
     sharedSelectColor: () => string | null;
 };
+//# sourceMappingURL=useSharedSelectEntity.d.ts.map

package/dist/components/erd/content-compass/ContentCompass.d.ts

@@ -0,0 +1,10 @@
+import { FC } from '@dineug/r-html';
+export type ContentCompassProps = {};
+/**
+ * The one thing on a screen that has been panned off every table and memo: an
+ * arrow at the nearest of them, how far off it lies, and a press that puts it
+ * back in the middle of the screen.
+ */
+declare const ContentCompass: FC<ContentCompassProps>;
+export default ContentCompass;
+//# sourceMappingURL=ContentCompass.d.ts.map

package/dist/components/erd/content-compass/ContentCompass.styles.d.ts

@@ -0,0 +1,3 @@
+export declare const compass: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const distance: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=ContentCompass.styles.d.ts.map

package/dist/components/erd/content-compass/compassGeometry.d.ts

@@ -0,0 +1,24 @@
+import { RootState } from '../../../engine/state';
+import { Point } from '../../../internal-types';
+/** Which way the nearest entity lies and how far, while the screen holds none. */
+export type ContentCompass = {
+    /** Degrees clockwise from east, which is the rotation the arrow is drawn at. */
+    angle: number;
+    /** The gap between the screen and that entity, in scene units. */
+    distance: number;
+    /** Its middle, which is the scene point a press centres the screen on. */
+    target: Point;
+};
+/**
+ * Where the nearest entity stands when the screen shows none of them, measured
+ * from the screen's own middle. Null while any table or memo reaches the screen,
+ * touching it counting as reaching it, and null while nobody has measured one.
+ */
+export declare function getContentCompass(state: RootState): ContentCompass | null;
+/**
+ * The gap as the pill prints it: whole scene units under a thousand, then
+ * thousands, millions and billions carrying one decimal under ten, so the label
+ * stays four characters wide however far the view has been carried.
+ */
+export declare function formatDistance(distance: number): string;
+//# sourceMappingURL=compassGeometry.d.ts.map

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

@@ -7,3 +7,4 @@ export type DiffViewerProps = {
 };
 declare const DiffViewer: FC<DiffViewerProps>;
 export default DiffViewer;
+//# sourceMappingURL=DiffViewer.d.ts.map

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

@@ -1,3 +1,4 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const container: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const viewport: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=DiffViewer.styles.d.ts.map

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

@@ -17,3 +17,4 @@ export declare function diffState(prevState: RootState, state: RootState): [Diff
 export declare function getNameToTableMap({ doc: { tableIds }, collections, }: RootState): NameToTableMap;
 export declare function getDiffStyle(diff: number, diffMap: DiffMap): HTMLStyleElement;
 export {};
+//# sourceMappingURL=diff.d.ts.map

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

@@ -8,3 +8,4 @@ export type ErdViewerProps = {
 };
 declare const ErdViewer: FC<ErdViewerProps>;
 export default ErdViewer;
+//# sourceMappingURL=ErdViewer.d.ts.map

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

@@ -1 +1,2 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=ErdViewer.styles.d.ts.map

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

@@ -9,3 +9,4 @@ export type TreeViewerProps = {
 };
 declare const TreeViewer: FC<TreeViewerProps>;
 export default TreeViewer;
+//# sourceMappingURL=TreeViewer.d.ts.map

package/dist/components/erd/diff-viewer/tree-viewer/TreeViewer.styles.d.ts

@@ -3,3 +3,4 @@ export declare const icon: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const table: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const column: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const ellipsis: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=TreeViewer.styles.d.ts.map

package/dist/components/erd/erd-context-menu/ErdContextMenu.d.ts

@@ -1,4 +1,4 @@
-import { FC, Ref } from '@dineug/r-html';
+import { FC } from '@dineug/r-html';
 import { ValuesType } from '../../../internal-types';
 export declare const ErdContextMenuType: {
     readonly ERD: "ERD";
@@ -8,10 +8,10 @@ export declare const ErdContextMenuType: {
 export type ErdContextMenuType = ValuesType<typeof ErdContextMenuType>;
 export type ErdContextMenuProps = {
     type: ErdContextMenuType;
-    canvas: Ref<HTMLDivElement>;
     relationshipId?: string;
     tableId?: string;
     onClose: () => void;
 };
 declare const ErdContextMenu: FC<ErdContextMenuProps>;
 export default ErdContextMenu;
+//# sourceMappingURL=ErdContextMenu.d.ts.map

package/dist/components/erd/erd-context-menu/menus/databaseMenus.d.ts

@@ -10,3 +10,4 @@ export declare function createDatabaseMenus({ store }: AppContext): {
     onClick: () => void;
 }[];
 export {};
+//# sourceMappingURL=databaseMenus.d.ts.map

package/dist/components/erd/erd-context-menu/menus/drawRelationshipMenus.d.ts

@@ -1,8 +1,8 @@
 import { AppContext } from '../../../appContext';
-import { Base64IconName } from '../../../primitives/icon/icons';
+import { NotationIconName } from '../../../primitives/icon/icons';
 import { KeyBindingName } from '../../../../utils/keyboard-shortcut';
 type Menu = {
-    iconName: Base64IconName;
+    iconName: NotationIconName;
     name: string;
     keyBindingName: KeyBindingName;
     relationshipType: number;
@@ -15,3 +15,4 @@ export declare function createDrawRelationshipMenus({ store, keyBindingMap }: Ap
     onClick: () => void;
 }[];
 export {};
+//# sourceMappingURL=drawRelationshipMenus.d.ts.map

package/dist/components/erd/erd-context-menu/menus/exportMenus.d.ts

@@ -1,9 +1,11 @@
 import { AppContext } from '../../../appContext';
 import { IconName } from '../../../primitives/icon/icons';
+import { Theme } from '../../../../themes/tokens';
 type Menu = {
     icon: IconName;
     name: string;
     onClick: () => void;
 };
-export declare function createExportMenus(app: AppContext, onClose: () => void, root: HTMLElement): Menu[];
+export declare function createExportMenus(app: AppContext, onClose: () => void, theme: Theme): Menu[];
 export {};
+//# sourceMappingURL=exportMenus.d.ts.map

package/dist/components/erd/erd-context-menu/menus/importMenus.d.ts

@@ -7,3 +7,4 @@ type Menu = {
 };
 export declare function createImportMenus(app: AppContext, onClose: () => void): Menu[];
 export {};
+//# sourceMappingURL=importMenus.d.ts.map

package/dist/components/erd/erd-context-menu/menus/relationshipMenus.d.ts

@@ -5,3 +5,4 @@ export declare function createRelationshipMenus({ store }: AppContext, relations
     name: string;
     onClick: () => void;
 }[];
+//# sourceMappingURL=relationshipMenus.d.ts.map

package/dist/components/erd/erd-context-menu/menus/showMenus.d.ts

@@ -4,3 +4,4 @@ export declare function createShowMenus({ store }: AppContext): {
     name: string;
     onClick: () => void;
 }[];
+//# sourceMappingURL=showMenus.d.ts.map

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

@@ -1,3 +1,4 @@
 import { Observable } from 'rxjs';
 import { RootState } from '../../engine/state';
 export declare const erdShortcutPerformCheck: ({ editor, settings }: RootState) => <T>(source$: Observable<T>) => Observable<T>;
+//# sourceMappingURL=erdShortcutPerformCheck.d.ts.map

package/dist/components/erd/floating-toolbar/FloatingToolbar.d.ts

@@ -0,0 +1,10 @@
+import { FC } from '@dineug/r-html';
+export type FloatingToolbarProps = {};
+/**
+ * The tools over the canvas: which of the two a press means, the notation the
+ * next relationship is drawn in, and zen mode. It is the one surface zen mode
+ * leaves standing, because the way out of zen mode is in it.
+ */
+declare const FloatingToolbar: FC<FloatingToolbarProps>;
+export default FloatingToolbar;
+//# sourceMappingURL=FloatingToolbar.d.ts.map

package/dist/components/erd/floating-toolbar/FloatingToolbar.styles.d.ts

@@ -0,0 +1,4 @@
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const menu: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const divider: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=FloatingToolbar.styles.d.ts.map

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

@@ -0,0 +1,23 @@
+import { Stage } from 'konva/lib/Stage';
+/** The scene entities the erd routing tells apart from one another. */
+export type SceneEntityKind = 'table' | 'memo' | 'relationship';
+export type SceneHit = {
+    kind: SceneEntityKind;
+    id: string;
+};
+/**
+ * Records the entity konva hit for every press a stage dispatches, and returns
+ * the teardown. Konva resolves the node while the hit canvas still matches the
+ * scene, so the walk up to the entity runs there too.
+ *
+ * @example
+ * addUnsubscribe(trackSceneHits(stage));
+ */
+export declare function trackSceneHits(stage: Stage): () => void;
+/**
+ * The scene entity a pointer event landed on, or null for bare canvas and for a
+ * target outside the stage. Konva resolved it as it dispatched that same event,
+ * because the press has re-rendered the scene by the time this is asked.
+ */
+export declare function sceneHit(container: HTMLElement | null | undefined, event: MouseEvent | TouchEvent): SceneHit | null;
+//# sourceMappingURL=hitTest.d.ts.map

package/dist/components/erd/minimap/Minimap.d.ts

@@ -2,3 +2,4 @@ import { FC } from '@dineug/r-html';
 export type MinimapProps = {};
 declare const Minimap: FC<MinimapProps>;
 export default Minimap;
+//# sourceMappingURL=Minimap.d.ts.map

package/dist/components/erd/minimap/Minimap.styles.d.ts

@@ -1,3 +1,3 @@
 export declare const minimap: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const border: import('@dineug/r-html').CSSTemplateLiterals;
-export declare const canvasSvg: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=Minimap.styles.d.ts.map

package/dist/components/erd/minimap/MinimapScene.d.ts

@@ -0,0 +1,17 @@
+import { FC } from '@dineug/r-html';
+import { Stage } from 'konva/lib/Stage';
+export type MinimapSceneProps = {};
+/**
+ * The whole document on one layer, with no culling: a thumbnail that dropped
+ * what is off screen would stop being a map of where the rest of it is. Boxes
+ * only, because a connector between two of them is noise at this size.
+ */
+declare const MinimapScene: FC<MinimapSceneProps>;
+/**
+ * Renders the minimap scene as the root of its Stage. Named in lower case on
+ * purpose: an all-upper-case export list makes r-html's refresh treat this as a
+ * component module and self-accept it, which kills hmr for the whole scene.
+ */
+export declare function renderMinimapScene(stage: Stage): void;
+export default MinimapScene;
+//# sourceMappingURL=MinimapScene.d.ts.map

package/dist/components/erd/minimap/memo/Memo.d.ts

@@ -2,6 +2,14 @@ import { FC } from '@dineug/r-html';
 import { Memo } from '../../../../internal-types';
 export type MemoProps = {
     memo: Memo;
+    /** Thumbnail pixels per scene unit, which is what the box is floored at. */
+    ratio: number;
 };
+/**
+ * A memo as the minimap draws it: the box and nothing in it, no smaller than a
+ * mark however far the map is folded. The id rides in the name, the way a
+ * relationship carries its own, as an id on a second stage would make an id scan ambiguous.
+ */
 declare const Memo: FC<MemoProps>;
 export default Memo;
+//# sourceMappingURL=Memo.d.ts.map

package/dist/components/erd/minimap/minimapGeometry.d.ts

@@ -0,0 +1,100 @@
+import { ScrollRanges } from '../../../engine/modules/settings/atom.actions';
+import { RootState } from '../../../engine/state';
+import { Point } from '../../../internal-types';
+import { Rect } from '../../../konva/scene/metrics';
+import { SceneTransform } from '../../../konva/scene/viewport';
+/** The scene placement plus the screen looking at it, which is all a visible rect is read from. */
+export type ViewTransform = SceneTransform & {
+    viewportWidth: number;
+    viewportHeight: number;
+};
+/**
+ * Scene units kept clear around what the map holds, so a box at the edge of the
+ * content never touches the edge of the thumbnail.
+ */
+export declare const MINIMAP_MAP_MARGIN = 100;
+/**
+ * The grid the map's edges snap outward to, in scene units. A table nudged a
+ * few pixels then leaves the map where it is, where a map cut to the content
+ * would rescale the thumbnail under every move.
+ */
+export declare const MINIMAP_MAP_STEP = 500;
+/**
+ * The thumbnail's shorter side never draws thinner than this, in pixels. Two
+ * tables fifty thousand units apart would fold it into a hairline otherwise,
+ * so the map is widened about its middle along that axis until it fits.
+ */
+export declare const MINIMAP_BOX_MIN_SIDE = 30;
+/**
+ * The smallest anything drawn on the thumbnail may be, in pixels: a table or
+ * memo box, or the handle. At the ratio a far flung document folds into, a
+ * box would draw sub-pixel and the map would show nothing of what it maps.
+ */
+export declare const MINIMAP_MARK_MIN = 3;
+/** How the thumbnail lays the document out: the scene rect it maps and the box that draws it. */
+export type MinimapLayout = {
+    /** The scene rect the thumbnail is a map of, in scene units. */
+    map: Rect;
+    /** Thumbnail pixels per scene unit: the map's longer side folded into MINIMAP_SIZE. */
+    ratio: number;
+    /** The thumbnail's own box, the map at the ratio, so its longer side is MINIMAP_SIZE. */
+    box: {
+        width: number;
+        height: number;
+    };
+    /** Where the box sits inside the MINIMAP_SIZE square, centred along its shorter side. */
+    offset: Point;
+};
+/** The view as the store holds it, for every reader that maps the screen onto the thumbnail. */
+export declare function getViewTransform(state: RootState): ViewTransform;
+/**
+ * The scene the screen actually covers, read back through the very origin
+ * getSceneOrigin places the scene layer at. One screen pixel buys one over the
+ * zoom in scene units, so zooming out widens this with the origin standing still.
+ */
+export declare function getVisibleCanvasRect(view: ViewTransform): Rect;
+/**
+ * The scene the screen can be scrolled over: what it shows at either end of
+ * the travel, and everything between. The far end of the travel puts the near
+ * edge of the content on the far edge of the screen, and the other way about.
+ */
+export declare function getReachRect(view: ViewTransform, { left, top }: ScrollRanges): Rect;
+/**
+ * The map is everything the screen can be scrolled over, with the margin
+ * around it, snapped to the grid, then widened along its shorter side where
+ * that would draw under MINIMAP_BOX_MIN_SIDE. A drag holds its content still.
+ */
+export declare function getMinimapLayout(state: RootState): MinimapLayout;
+/** A scene point in the thumbnail's own pixels; scene zero lands where the layer is placed. */
+export declare function toMinimapPoint({ map, ratio }: MinimapLayout, point: Point): Point;
+/** The scene point under a thumbnail pixel, the mapping above inverted. */
+export declare function fromMinimapPoint({ map, ratio }: MinimapLayout, point: Point): Point;
+/** The screen's own footprint in thumbnail pixels, the visible rect mapped and untrimmed. */
+export declare function getMinimapViewportRect(layout: MinimapLayout, view: ViewTransform): Rect;
+/**
+ * A scene rect as the thumbnail draws it: the rect itself, or one grown about
+ * its middle to MINIMAP_MARK_MIN pixels at the map's ratio where it would draw
+ * smaller. In scene units, since the layer it lands on carries the ratio.
+ */
+export declare function getMinimapMarkRect(ratio: number, rect: Rect): Rect;
+/**
+ * The rectangle as drawn, no smaller than a mark and trimmed to the thumbnail
+ * box. A map laid out for the view holds its screen whole; the trim is for one
+ * drawn against another view's map, since a pointer target must not hang over the canvas.
+ */
+export declare function getMinimapHandleRect(layout: MinimapLayout, view: ViewTransform): Rect;
+/**
+ * A scene distance as the origin travel that covers it. The origin is measured
+ * in screen pixels and moves the view the opposite way, so it carries both the
+ * zoom and the sign that a minimap coordinate does not.
+ */
+export declare function toScrollDistance(distance: number, zoomLevel: number): number;
+/** Minimap travel as the origin travel that keeps the rectangle under the pointer. */
+export declare function toScrollMovement(movement: number, ratio: number, zoomLevel: number): number;
+/**
+ * The origin that puts a scene point in the middle of the screen. Stated as a
+ * step away from where the origin stands now, so it is read once through
+ * getVisibleCanvasRect rather than restated inverted here.
+ */
+export declare function getScrollToCenter(view: ViewTransform, center: Point): Point;
+//# sourceMappingURL=minimapGeometry.d.ts.map

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

@@ -2,6 +2,14 @@ import { FC } from '@dineug/r-html';
 import { Table } from '../../../../internal-types';
 export type TableProps = {
     table: Table;
+    /** Thumbnail pixels per scene unit, which is what the box is floored at. */
+    ratio: number;
 };
+/**
+ * A table as the minimap draws it: the box and nothing in it, no smaller than a
+ * mark however far the map is folded. The id stays off the node because two
+ * stages spelling one id make an id scan ambiguous, so it is found by name and table.
+ */
 declare const Table: FC<TableProps>;
 export default Table;
+//# sourceMappingURL=Table.d.ts.map

package/dist/components/erd/minimap/useMinimapScroll.d.ts

@@ -5,3 +5,4 @@ export declare function useMinimapScroll(ctx: Ctx): {
     };
     onScrollStart: (event: MouseEvent | TouchEvent) => void;
 };
+//# sourceMappingURL=useMinimapScroll.d.ts.map

package/dist/components/erd/minimap/viewport/Viewport.d.ts

@@ -4,3 +4,4 @@ export type ViewportProps = {
 };
 declare const Viewport: FC<ViewportProps>;
 export default Viewport;
+//# sourceMappingURL=Viewport.d.ts.map

package/dist/components/erd/minimap/viewport/Viewport.styles.d.ts

@@ -1 +1,2 @@
 export declare const viewport: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=Viewport.styles.d.ts.map

package/dist/components/erd/table-properties/TableProperties.d.ts

@@ -7,3 +7,4 @@ export type TablePropertiesProps = {
 };
 declare const TableProperties: FC<TablePropertiesProps>;
 export default TableProperties;
+//# sourceMappingURL=TableProperties.d.ts.map

package/dist/components/erd/table-properties/TableProperties.styles.d.ts

@@ -4,3 +4,4 @@ export declare const scrollbarArea: import('@dineug/r-html').CSSTemplateLiterals
 export declare const header: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const tab: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const scope: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=TableProperties.styles.d.ts.map

package/dist/components/erd/table-properties/table-properties-indexes/TablePropertiesIndexes.d.ts

@@ -4,3 +4,4 @@ export type TablePropertiesIndexesProps = {
 };
 declare const TablePropertiesIndexes: FC<TablePropertiesIndexesProps>;
 export default TablePropertiesIndexes;
+//# sourceMappingURL=TablePropertiesIndexes.d.ts.map

package/dist/components/erd/table-properties/table-properties-indexes/TablePropertiesIndexes.styles.d.ts

@@ -1,3 +1,4 @@
 export declare const leftArea: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const rightArea: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const addIndexButtonArea: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=TablePropertiesIndexes.styles.d.ts.map

package/dist/components/erd/table-properties/table-properties-indexes/indexes-checkbox-column/IndexesCheckboxColumn.d.ts

@@ -6,3 +6,4 @@ export type IndexesCheckboxColumnProps = {
 };
 declare const IndexesCheckboxColumn: FC<IndexesCheckboxColumnProps>;
 export default IndexesCheckboxColumn;
+//# sourceMappingURL=IndexesCheckboxColumn.d.ts.map

package/dist/components/erd/table-properties/table-properties-indexes/indexes-checkbox-column/IndexesCheckboxColumn.styles.d.ts

@@ -1 +1,2 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=IndexesCheckboxColumn.styles.d.ts.map