@dineug/erd-editor 3.4.0 → 3.6.0

package/dist/services/export-png/ExportScene.d.ts

@@ -0,0 +1,16 @@
+import { FC } from '@dineug/r-html';
+import { Rect } from '../../konva/scene/metrics';
+export type ExportSceneProps = {
+    /** The scene box the image holds, margin included, in scene units. */
+    box: Rect;
+    /** What the box is scaled by so a canvas can hold the raster of it. */
+    scale: number;
+};
+/**
+ * Everything the document draws on one layer, with no culling. The zoom reaches
+ * the image, in the scale the layer is placed at and in the spelling a table is
+ * drawn with; the scroll and the viewport do not, so the whole document is held.
+ */
+declare const ExportScene: FC<ExportSceneProps>;
+export default ExportScene;
+//# sourceMappingURL=ExportScene.d.ts.map

package/dist/services/export-png/documentScene.d.ts

@@ -0,0 +1,33 @@
+import { Stage } from 'konva/lib/Stage';
+import { Rect } from '../../konva/scene/metrics';
+import { Theme } from '../../themes/tokens';
+export type DocumentSceneOptions = {
+    doc: string;
+    theme: Theme;
+    toWidth: (text: string) => number;
+    /**
+     * The zoom to draw at, for a caller whose editor is at one the document does
+     * not carry. Left out, the document's own zoom is what the image is drawn at.
+     */
+    zoomLevel?: number;
+};
+export type DocumentScene = {
+    stage: Stage;
+    /** What the Stage holds, in scene units, before it was scaled to fit. */
+    box: Rect;
+    /** The factor between that box and the Stage the scene was drawn on. */
+    scale: number;
+    /** The zoom that was asked for, which scale is that cut to what a canvas holds. */
+    zoomLevel: number;
+    destroy: () => void;
+};
+/**
+ * The whole document on a Stage of its own, off any screen. The store is built
+ * here rather than borrowed, so the editor's scroll and selection cannot reach
+ * the image and it holds the whole document however it was being looked at.
+ *
+ * @example
+ * const scene = await renderDocumentScene({ doc, theme, toWidth });
+ */
+export declare function renderDocumentScene({ doc, theme, toWidth, zoomLevel, }: DocumentSceneOptions): Promise<DocumentScene>;
+//# sourceMappingURL=documentScene.d.ts.map

package/dist/services/export-png/exportBox.d.ts

@@ -0,0 +1,27 @@
+import { RootState } from '../../engine/state';
+import { Rect } from '../../konva/scene/metrics';
+/**
+ * The breathing room around the drawn document, in scene units, and nothing
+ * more: a connector measured against a retired sort epoch is already inflated
+ * by getRouteBBox itself, and the union below holds that box before this is added.
+ */
+export declare const EXPORT_MARGIN = 80;
+/**
+ * Everything the image has to hold: every table and memo, every connector the
+ * document is set to show, and the margin around the lot. An empty document is
+ * the margin on its own, which is a box a canvas can still hold.
+ *
+ * @example
+ * const box = getExportRect(store.state);
+ */
+export declare function getExportRect(state: RootState): Rect;
+/**
+ * What the box is drawn at: the zoom the image was asked for, cut to whatever a
+ * canvas can hold. A document is unbounded now, so this is what keeps the Stage
+ * itself inside the ceiling that fitPixelRatio keeps the raster inside.
+ *
+ * @example
+ * const scale = getExportScale(getExportRect(store.state), settings.zoomLevel);
+ */
+export declare function getExportScale({ width, height }: Rect, zoomLevel?: number): number;
+//# sourceMappingURL=exportBox.d.ts.map

package/dist/services/export-png/exportPng.shared-worker.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=exportPng.shared-worker.d.ts.map

package/dist/services/export-png/exportPngService.d.ts

@@ -0,0 +1,25 @@
+import { RenderPngRequest, RenderPngResult } from './renderPng';
+/**
+ * A png request as it crosses a realm boundary. The measurement itself cannot
+ * cross, so what travels is the widths the asking realm read for the probe
+ * strings and the answering realm has to reproduce them.
+ */
+export type ExportPngRequest = RenderPngRequest & {
+    fontProbe: number[];
+};
+/**
+ * Draws a document off the thread that asked for it. Text is measured here
+ * rather than sent, because a table's reserved widths were laid out by a
+ * measurement, and a picture drawn by a different one does not fit them.
+ */
+export declare class ExportPngService {
+    /**
+     * What this realm lays the probe strings out to. Answering it at all proves
+     * the module graph evaluated here, which is the failure a shared worker
+     * reports to nobody: its port stays open and every call after it hangs.
+     */
+    probeFontWidths(): Promise<number[]>;
+    render(request: ExportPngRequest): Promise<RenderPngResult>;
+    private createToWidth;
+}
+//# sourceMappingURL=exportPngService.d.ts.map

package/dist/services/export-png/index.d.ts

@@ -0,0 +1,55 @@
+import { Theme } from '../../themes/tokens';
+import { ResolutionReduction } from './renderPng';
+import { ToWidth } from './textWidth';
+export type { ResolutionReduction };
+/** Which thread drew the image, which is the one thing a Promise cannot say. */
+export type ExportPngRealm = 'worker' | 'main';
+/**
+ * Where an export has got to. Started fires before any drawing begins, and
+ * again naming the main thread if the worker it first named gave way; finished
+ * fires once, and only after a blob exists.
+ */
+export type ExportPngProgress = {
+    phase: 'started';
+    realm: ExportPngRealm;
+} | {
+    phase: 'finished';
+    realm: ExportPngRealm;
+    width: number;
+    height: number;
+};
+export type DocumentPngOptions = {
+    doc: string;
+    theme: Theme;
+    /**
+     * How the editor measures a string. A realm that draws the document has to
+     * reproduce this to the pixel, so it is passed to be compared against rather
+     * than to be called across a boundary a function does not cross.
+     */
+    toWidth: ToWidth;
+    pixelRatio?: number;
+    /**
+     * The zoom the image is drawn at, which is the editor's own rather than the
+     * document's whenever the author asked for the zoom not to be saved. Left
+     * out, the image is drawn at the zoom the document carries.
+     */
+    zoomLevel?: number;
+    /**
+     * Called once, after a file exists, when the box outran what a canvas holds
+     * and the image had to be scaled down. A caller with somewhere to put it is
+     * what turns a silent loss of resolution into something the author is told.
+     */
+    onResolutionReduced?: (reduction: ResolutionReduction) => void;
+    /** Called as the export moves, for a caller that shows it is running. */
+    onProgress?: (progress: ExportPngProgress) => void;
+};
+/**
+ * A png of everything the document draws, at the zoom it is being read at. The
+ * scene is drawn again from the document rather than read off the screen, so
+ * the image holds the whole document however far it was scrolled away.
+ *
+ * @example
+ * const blob = await createDocumentPng({ doc: toJson(store.state), theme, toWidth });
+ */
+export declare function createDocumentPng({ doc, theme, toWidth, pixelRatio, zoomLevel, onResolutionReduced, onProgress, }: DocumentPngOptions): Promise<Blob>;
+//# sourceMappingURL=index.d.ts.map

package/dist/services/export-png/pixelRatio.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The largest raster a browser canvas will hold, as area rather than as one
+ * side. Chromium and WebKit both stop at exactly this many pixels however the
+ * box is shaped, and Firefox stops well above it, so this is the shared floor.
+ */
+export declare const CANVAS_AREA_MAX: number;
+/**
+ * The longest single side, kept at half of the 65535 every engine measured here
+ * accepted. The margin is spent on the side rather than the area because no box
+ * the schema allows reaches it at one image pixel per canvas unit.
+ */
+export declare const CANVAS_SIDE_MAX = 32767;
+/**
+ * The ratio that keeps a raster of that box inside what a canvas can hold. A
+ * tall box is bounded by its area, so a document narrow enough to fit under the
+ * ceiling keeps every pixel it was written with instead of being scaled down.
+ *
+ * @example
+ * fitPixelRatio(1, 20000, 20000);
+ */
+export declare function fitPixelRatio(pixelRatio: number, width: number, height: number): number;
+//# sourceMappingURL=pixelRatio.d.ts.map

package/dist/services/export-png/renderPng.d.ts

@@ -0,0 +1,40 @@
+import { Theme } from '../../themes/tokens';
+import { ToWidth } from './textWidth';
+/** The box that was asked for and the raster that fitted inside a canvas. */
+export type ResolutionReduction = {
+    documentWidth: number;
+    documentHeight: number;
+    width: number;
+    height: number;
+};
+/** Everything a png needs that survives a structured clone to another realm. */
+export type RenderPngRequest = {
+    doc: string;
+    theme: Theme;
+    pixelRatio: number;
+    /** The zoom to draw at; the document's own when the caller names none. */
+    zoomLevel?: number;
+};
+export type RenderPngResult = {
+    blob: Blob;
+    width: number;
+    height: number;
+    /**
+     * Null when the box kept every pixel it was written with. A realm that drew
+     * the image is the only one that knows this, so it is carried back rather
+     * than recomputed by whoever asked for the file.
+     */
+    reduction: ResolutionReduction | null;
+};
+/**
+ * The whole document rastered, in whichever realm calls it. Nothing here reads
+ * a window, a screen or a stylesheet, so the same code answers on the main
+ * thread and inside the worker that keeps the main thread free.
+ *
+ * @example
+ * const { blob } = await renderDocumentPng({ doc, theme, pixelRatio: 1, toWidth });
+ */
+export declare function renderDocumentPng({ doc, theme, pixelRatio, zoomLevel, toWidth, }: RenderPngRequest & {
+    toWidth: ToWidth;
+}): Promise<RenderPngResult>;
+//# sourceMappingURL=renderPng.d.ts.map

package/dist/services/export-png/textWidth.d.ts

@@ -0,0 +1,28 @@
+/** How the editor measures a string, which is what a table reserves room by. */
+export type ToWidth = (text: string) => number;
+/** The shorthand utils/text.ts sets on the context it measures with. */
+export declare const SCENE_FONT: string;
+/**
+ * Strings a divergence in font resolution shows up in. Latin covers the head of
+ * the family list, the ideographs cover whatever the host falls through to for
+ * them, and the punctuation covers a face that carries only part of the range.
+ */
+export declare const FONT_PROBE_TEXTS: readonly ["ERD editor 0123456789", "가나다 漢字 テスト", "—…€· iIlL1"];
+/**
+ * The same measurement utils/text.ts makes, on a canvas no document holds. A
+ * realm off the screen has no element to fall back to, so a realm with no 2d
+ * context has no way to lay a document out and says so rather than guessing.
+ */
+export declare function createOffscreenToWidth(): ToWidth | null;
+/**
+ * What the probe strings measure under one realm's font resolution. Comparing
+ * two of these is the only gate that fires: a worker's fonts.load resolves for
+ * a family it does not have, and fonts.check answers true for one nobody has.
+ *
+ * @example
+ * measureFontProbe(toWidth);
+ */
+export declare function measureFontProbe(toWidth: ToWidth): number[];
+/** Whether two realms lay the probe strings out to the same pixel. */
+export declare function sameFontProbe(a: number[], b: number[]): boolean;
+//# sourceMappingURL=textWidth.d.ts.map

package/dist/services/schema-gc/index.d.ts

@@ -7,4 +7,12 @@ export type GCIds = {
     indexColumnIds: string[];
     memoIds: string[];
 };
-export declare function getSchemaGCService(): SchemaGCService | null;
+/** What a caller gets: the collector's one method, wherever it runs. */
+export type SchemaGCRunner = Pick<SchemaGCService, 'run'>;
+/**
+ * Runs the collector off the main thread where a host builds a shared worker.
+ * There is no dedicated Worker rung between the two, because a second worker
+ * file is a second copy of this whole service for the consumer to ship.
+ */
+export declare function getSchemaGCService(): SchemaGCRunner | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/services/schema-gc/procGC.d.ts

@@ -1,3 +1,4 @@
 import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
 import { GCIds } from '.';
 export declare function procGC({ collections }: ERDEditorSchemaV3, { tableIds, tableColumnIds, relationshipIds, indexIds, indexColumnIds, memoIds, }: GCIds): void;
+//# sourceMappingURL=procGC.d.ts.map

package/dist/services/schema-gc/schemaGC.shared-worker.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=schemaGC.shared-worker.d.ts.map

package/dist/services/schema-gc/schemaGCService.d.ts

@@ -2,3 +2,4 @@ import { GCIds } from '.';
 export declare class SchemaGCService {
     run(source: string): Promise<GCIds>;
 }
+//# sourceMappingURL=schemaGCService.d.ts.map

package/dist/services/shikiService.d.ts

@@ -6,3 +6,4 @@ export type ShikiService = {
 };
 export declare function setGetShikiServiceCallback(callback: () => ShikiService | null): void;
 export declare function getShikiService(): ShikiService | null;
+//# sourceMappingURL=shikiService.d.ts.map

package/dist/styles/colorPicker.style.d.ts

@@ -1,10 +1,7 @@
 /**
- * Vendored from https://github.com/easylogic/colorpicker.
- *
- * Global, not scoped. The picker's markup is built by the upstream library at runtime, outside
- * anything r-html renders, so there is no element here to hang a generated component class on —
- * every selector below matches by the literal class names that library writes
- * (`.easylogic-colorpicker`, `.colorsets-contextmenu`), and scoping them would rename them out
- * from under it. Last in `setGlobalStyleOrder`, which is where it sat when it was a tree `<style>`.
+ * Vendored from https://github.com/easylogic/colorpicker. Global, not scoped:
+ * the upstream library builds its own markup at runtime, so every selector below
+ * matches literal class names that scoping would rename out from under it.
  */
 export declare const colorPickerStyle: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=colorPicker.style.d.ts.map

package/dist/styles/fonts.styles.d.ts

@@ -1,4 +1,5 @@
 export declare const TextFontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', 'Open Sans', system-ui, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji'";
 export declare const CodeFontFamily: "'Menlo', 'Consolas', 'Bitstream Vera Sans Mono', monospace, 'Apple Color Emoji', 'Segoe UI Emoji'";
-/** Global, not scoped: `:host` is the shadow host, which no component class matches. */
+/** Global, not scoped: :host is the shadow host, which no component class matches. */
 export declare const fontsStyle: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=fonts.styles.d.ts.map

package/dist/styles/reset.styles.d.ts

@@ -1,5 +1,6 @@
 /**
- * Global, not scoped: every selector here is a type selector, the universal selector or `:host`,
+ * Global, not scoped: every selector here is a type selector, the universal selector or :host,
  * none of which survives having a component class prepended to it.
  */
 export declare const resetStyle: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=reset.styles.d.ts.map

package/dist/styles/scrollbar.styles.d.ts

@@ -1,6 +1,7 @@
 /**
- * Global, not scoped. The `::-webkit-scrollbar*` pseudo elements have no element of their own to
- * hang a component class on, and `.scrollbar` is a hook class seven components opt into by
- * literal name (`class=${['scrollbar', ...]}`) — scoping it would rename it out from under them.
+ * Global, not scoped. The ::-webkit-scrollbar* pseudo elements have no element of their own to
+ * hang a component class on, and .scrollbar is a hook class seven components opt into by
+ * literal name (class=${['scrollbar', ...]}) — scoping it would rename it out from under them.
  */
 export declare const scrollbarStyle: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=scrollbar.styles.d.ts.map

package/dist/styles/typography.styles.d.ts

@@ -11,5 +11,6 @@ export declare const typography: {
     readonly normal: import('@dineug/r-html').CSSTemplateLiterals;
     readonly paragraph: import('@dineug/r-html').CSSTemplateLiterals;
 };
-/** Global, not scoped: `:host` is the shadow host, which no component class matches. */
+/** Global, not scoped: :host is the shadow host, which no component class matches. */
 export declare const typographyStyle: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=typography.styles.d.ts.map

package/dist/themes/radix-ui-theme.config.d.ts

@@ -1,2 +1,3 @@
 import { Theme } from './tokens';
 export declare const ThemeConfig: Theme;
+//# sourceMappingURL=radix-ui-theme.config.d.ts.map

package/dist/themes/radix-ui-theme.d.ts

@@ -1790,3 +1790,4 @@ export type ThemeOptions = {
     accentColor: AccentColor;
 };
 export declare const createTheme: ({ grayColor, accentColor, appearance, }: ThemeOptions) => Theme;
+//# sourceMappingURL=radix-ui-theme.d.ts.map

package/dist/themes/tokens.d.ts

@@ -66,4 +66,9 @@ export type Theme = {
     diffCrossForeground: string;
 };
 export declare const ThemeTokens: ReadonlyArray<keyof Theme>;
+/** The custom property one token is published under on :host. */
+export declare const toThemeVariableName: (token: string) => string;
+/** The custom property a host document overrides that token through. */
+export declare const toThemeOverrideVariableName: (token: string) => string;
 export declare const themeToTokensString: (theme: Theme) => string;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/utils/arrayHas.d.ts

@@ -0,0 +1,3 @@
+/** A membership test over one array, built once so a hot path asks a Set rather than an array. */
+export declare function arrayHas<T>(arr: Array<T> | ReadonlyArray<T>): (value: T) => boolean;
+//# sourceMappingURL=arrayHas.d.ts.map

package/dist/utils/attribute.d.ts

@@ -1 +1,2 @@
 export declare function restAttrs(value: Record<string, any>): Record<string, any>;
+//# sourceMappingURL=attribute.d.ts.map

package/dist/utils/bit.d.ts

@@ -1 +1,2 @@
 export declare function bHas(bit: number, value: number): boolean;
+//# sourceMappingURL=bit.d.ts.map

package/dist/utils/calcMemo.d.ts

@@ -1,3 +1,4 @@
 import { Memo } from '../internal-types';
 export declare function calcMemoWidth(memo: Memo): number;
 export declare function calcMemoHeight(memo: Memo): number;
+//# sourceMappingURL=calcMemo.d.ts.map

package/dist/utils/calcTable.d.ts

@@ -3,7 +3,7 @@ import { RootState } from '../engine/state';
 import { Table } from '../internal-types';
 export declare function getWidthGeneration(): number;
 /**
- * Invalidates every cached table size. Called from `recalculateTableWidth`,
+ * Invalidates every cached table size. Called from recalculateTableWidth,
  * which rewrites widths without dispatching an action, and from the
  * relationship-sort hook for any action that is not a pure move.
  */
@@ -21,3 +21,4 @@ export type ColumnWidth = {
 };
 export declare function calcTableHeight(table: Table): number;
 export declare function recalculateTableWidth({ doc: { tableIds }, collections }: RootState, { toWidth }: EngineContext): void;
+//# sourceMappingURL=calcTable.d.ts.map

package/dist/utils/clipboard.d.ts

@@ -1 +1,2 @@
 export declare function copyToClipboard(value: string): Promise<void>;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/utils/collection/index.entity.d.ts

@@ -1,2 +1,3 @@
 import { DeepPartial, Index } from '../../internal-types';
 export declare const createIndex: (value?: DeepPartial<Index>) => Index;
+//# sourceMappingURL=index.entity.d.ts.map

package/dist/utils/collection/indexColumn.entity.d.ts

@@ -1,2 +1,3 @@
 import { DeepPartial, IndexColumn } from '../../internal-types';
 export declare const createIndexColumn: (value?: DeepPartial<IndexColumn>) => IndexColumn;
+//# sourceMappingURL=indexColumn.entity.d.ts.map

package/dist/utils/collection/memo.entity.d.ts

@@ -1,2 +1,3 @@
 import { DeepPartial, Memo } from '../../internal-types';
 export declare const createMemo: (value?: DeepPartial<Memo>) => Memo;
+//# sourceMappingURL=memo.entity.d.ts.map

package/dist/utils/collection/relationship.entity.d.ts

@@ -1,2 +1,3 @@
 import { DeepPartial, Relationship } from '../../internal-types';
 export declare const createRelationship: (value?: DeepPartial<Relationship>) => Relationship;
+//# sourceMappingURL=relationship.entity.d.ts.map

package/dist/utils/collection/sequence.d.ts

@@ -1 +1,2 @@
 export declare function addAndSort(ids: string[], seqIds: string[], id: string): void;
+//# sourceMappingURL=sequence.d.ts.map

package/dist/utils/collection/table.entity.d.ts

@@ -1,2 +1,3 @@
 import { DeepPartial, Table } from '../../internal-types';
 export declare const createTable: (value?: DeepPartial<Table>) => Table;
+//# sourceMappingURL=table.entity.d.ts.map

package/dist/utils/collection/tableColumn.entity.d.ts

@@ -1,2 +1,3 @@
 import { Column, DeepPartial } from '../../internal-types';
 export declare const createColumn: (value?: DeepPartial<Column>) => Column;
+//# sourceMappingURL=tableColumn.entity.d.ts.map

package/dist/utils/device-detect/index.d.ts

@@ -6,3 +6,4 @@ export declare const hasWindows: () => boolean;
 export declare const hasChrome: () => boolean;
 export declare const hasSafari: () => boolean;
 export declare const hasFirefox: () => boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/domEvent.d.ts

@@ -4,3 +4,4 @@ export declare function onStop(event: Event): void;
 export declare function onStopImmediate(event: Event): void;
 export declare function isMouseEvent(event: Event): event is MouseEvent;
 export declare function isTouchEvent(event: Event): event is TouchEvent;
+//# sourceMappingURL=domEvent.d.ts.map

package/dist/utils/dragSelect.d.ts

@@ -1,4 +1,3 @@
-import { Point } from '../internal-types';
 type PointToPoint = {
     x1: number;
     y1: number;
@@ -13,11 +12,5 @@ export type Rect = {
 };
 export declare function isOverlapPosition(dragRect: Rect, rect: Rect): boolean;
 export declare function getOverlapPosition(dragRect: Rect, rect: Rect): PointToPoint | null;
-export declare function getZoomViewport(width: number, height: number, zoomLevel: number): Rect;
-export declare const getAbsolutePosition: (overlapPosition: PointToPoint, zoomViewport: Rect, zoomLevel: number) => PointToPoint;
-export declare function getAbsoluteZoomPoint({ x, y }: Point, width: number, height: number, zoomLevel: number): {
-    x: number;
-    y: number;
-};
-export declare function getAbsolutePoint(point: Point, width: number, height: number, zoomLevel: number): Point;
 export {};
+//# sourceMappingURL=dragSelect.d.ts.map

package/dist/utils/draw-relationship/calc.d.ts

@@ -4,3 +4,4 @@ import { ObjectPoint } from '.';
 export declare function tableToObjectPoint(state: RootState, table: Table): ObjectPoint;
 export declare function euclideanDistance(a: Point, b: Point): number;
 export declare function manhattanDistance(a: Point, b: Point): number;
+//# sourceMappingURL=calc.d.ts.map

package/dist/utils/draw-relationship/chamfer.d.ts

@@ -1,2 +1,3 @@
 import { Point } from '../../internal-types';
 export declare function chamferPolyline(points: Point[], size: number): Point[];
+//# sourceMappingURL=chamfer.d.ts.map

package/dist/utils/draw-relationship/draw.d.ts

@@ -2,3 +2,4 @@ import { DrawRelationship } from '../../engine/modules/editor/state';
 import { RootState } from '../../engine/state';
 import { DrawPath } from '.';
 export declare function getDraw(state: RootState, draw: DrawRelationship): DrawPath;
+//# sourceMappingURL=draw.d.ts.map

package/dist/utils/draw-relationship/incremental.d.ts

@@ -0,0 +1,71 @@
+import { RootState } from '../../engine/state';
+import { Point } from '../../internal-types';
+import { Obstacles } from './route';
+export type DirtyBox = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/**
+ * A route and the inputs it was computed from, so the next sort can tell whether
+ * anything it reads has moved. Anchors are recomputed in full every sort, so the
+ * turning points below are what a changed anchor shows up as.
+ */
+export type RouteEntry = {
+    mx: number;
+    my: number;
+    mDirection: number;
+    lx: number;
+    ly: number;
+    lDirection: number;
+    startTableId: string;
+    endTableId: string;
+    /** The router's own output, before nudgeRoutes pushed anything apart. */
+    pristine: Point[];
+    /** What was finally drawn, which is what a reused group is put back onto. */
+    nudged: Point[];
+    bounds: DirtyBox;
+};
+export type SortCache = {
+    boxes: Map<string, DirtyBox>;
+    entries: Map<string, RouteEntry>;
+};
+export declare function getSortCache(state: RootState): SortCache;
+export declare function boundsOfPoints(points: Point[]): DirtyBox;
+/**
+ * Whether a moved table can change a route. The bounding box rather than the
+ * runs inside it: the router picks its lanes from every table reaching into the
+ * band between the two anchors, not only from the ones the route passes.
+ */
+export declare function routeTouches(bounds: DirtyBox, boxes: DirtyBox[]): boolean;
+/**
+ * Where this sort changed something, as lanes rather than as areas. Everything
+ * nudgeRoutes decides is decided one axis at a time, so a change is only ever
+ * felt by segments sharing that axis within a few lanes of it.
+ */
+export type DirtyLanes = {
+    markSpan(vertical: boolean, from: number, to: number, low: number, high: number): void;
+    markBox(box: DirtyBox): void;
+    hits(vertical: boolean, from: number, to: number, low: number, high: number): boolean;
+};
+export declare function createDirtyLanes(): DirtyLanes;
+/** Marks every axis-aligned run of a polyline as changed. */
+export declare function markRoute(lanes: DirtyLanes, points: Point[]): void;
+/**
+ * What nudgeRoutes needs to leave an untouched group where it already was: the
+ * routes this sort re-routed, the lanes they and the moved tables changed, and
+ * the coordinate every segment was last drawn at.
+ */
+export type NudgeMemo = {
+    dirty: Set<string>;
+    lanes: DirtyLanes;
+    coordinate(relationshipId: string, index: number, vertical: boolean): number | undefined;
+};
+/**
+ * Which table boxes moved since the last sort, or null when so much changed that
+ * filtering costs more than re-routing. The cache's own snapshot is replaced
+ * here, so this runs once per sort.
+ */
+export declare function diffTableBoxes(cache: SortCache, obstacles: Obstacles): DirtyBox[] | null;
+//# sourceMappingURL=incremental.d.ts.map