@dineug/erd-editor 3.5.0 → 3.7.0

package/dist/services/elk-layout/elkGraph.d.ts

@@ -0,0 +1,44 @@
+import { RootState } from '../../engine/state';
+import { ElkPlacement } from './elkLayoutOptions';
+export type ElkLayoutNode = {
+    id: string;
+    width: number;
+    height: number;
+};
+export type ElkLayoutEdge = {
+    source: string;
+    target: string;
+    /**
+     * Which row of each table the relationship meets, counted from the top, or
+     * -1 where the column it names is gone. A placement that hands ELK ports
+     * orders them by this, so a layout reads the connectors the editor draws.
+     */
+    sourceRow: number;
+    targetRow: number;
+};
+/**
+ * A layout as it crosses a realm boundary. Only the boxes and what joins them
+ * travel, so the answering realm measures no text and reads no document.
+ */
+export type ElkLayoutRequest = {
+    placement: ElkPlacement;
+    nodes: ElkLayoutNode[];
+    edges: ElkLayoutEdge[];
+};
+/** Where one table's top left corner ended up, in scene units. */
+export type ElkLayoutPoint = {
+    id: string;
+    x: number;
+    y: number;
+};
+export declare function createElkLayoutRequest(state: RootState, placement: ElkPlacement): ElkLayoutRequest;
+/**
+ * Where each table lands, over the middle of what the document already draws.
+ * ELK lays every graph out from its own origin, so a document placed twice
+ * would otherwise walk away from where it was read.
+ *
+ * @example
+ * onChange(toTablePoints(store.state, request, await createElkLayout(request)));
+ */
+export declare function toTablePoints(state: RootState, { nodes }: ElkLayoutRequest, points: ElkLayoutPoint[]): ElkLayoutPoint[];
+//# sourceMappingURL=elkGraph.d.ts.map

package/dist/services/elk-layout/elkLayout.shared-worker.d.ts

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

package/dist/services/elk-layout/elkLayoutOptions.d.ts

@@ -0,0 +1,25 @@
+import { LayoutOptions } from 'elkjs/lib/elk-api';
+import { TablePlacement } from '../../constants/tablePlacement';
+/** The placements ELK answers, which is every one but the force simulation. */
+export type ElkPlacement = Exclude<TablePlacement, typeof TablePlacement.force>;
+export declare function isElkPlacement(placement: TablePlacement): placement is ElkPlacement;
+/**
+ * Whether ELK is handed a port per relationship endpoint rather than a bare
+ * box. The layered placements ask only where a table goes; flow also says
+ * where each connector meets it, which is what pulls the crossings out.
+ */
+export declare function usesPorts(placement: ElkPlacement): boolean;
+/**
+ * What ELK is told, for the placement the author picked.
+ *
+ * @example
+ * const graph = { id: 'root', layoutOptions: elkLayoutOptions(placement) };
+ */
+export declare function elkLayoutOptions(placement: ElkPlacement): LayoutOptions;
+/**
+ * Every algorithm the placements name. ELK registers the metadata of these and
+ * no others, so it is read off the options rather than listed: a placement
+ * naming an algorithm left out here would be answered with an error.
+ */
+export declare const ELK_ALGORITHMS: string[];
+//# sourceMappingURL=elkLayoutOptions.d.ts.map

package/dist/services/elk-layout/elkLayoutService.d.ts

@@ -0,0 +1,21 @@
+import { ElkNode, ElkPort } from 'elkjs/lib/elk-api';
+import { ElkLayoutEdge, ElkLayoutPoint, ElkLayoutRequest } from './elkGraph';
+/** One port per relationship endpoint, grouped by the table it sits on. */
+export declare function portsByNode(edges: ElkLayoutEdge[]): Map<string, ElkPort[]>;
+/** The graph ELK is handed, which is flat: an ERD nests no table in another. */
+export declare function toElkGraph({ placement, nodes, edges, }: ElkLayoutRequest): ElkNode;
+/**
+ * Places tables by an ELK algorithm, off the thread that asked for it. What
+ * comes back is a corner per table and nothing else, because the editor routes
+ * its own relationship lines and drops the sections ELK computed for them.
+ */
+export declare class ElkLayoutService {
+    /**
+     * Loading ELK at all is what proves this realm can run it. A shared worker
+     * that throws while evaluating reports it to the console and to nobody else:
+     * its port stays open and every call after it hangs.
+     */
+    ready(): Promise<boolean>;
+    layout(request: ElkLayoutRequest): Promise<ElkLayoutPoint[]>;
+}
+//# sourceMappingURL=elkLayoutService.d.ts.map

package/dist/services/elk-layout/elkWorkerRealm.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=elkWorkerRealm.d.ts.map

package/dist/services/elk-layout/index.d.ts

@@ -0,0 +1,13 @@
+import { ElkLayoutPoint, ElkLayoutRequest } from './elkGraph';
+export { createElkLayoutRequest, type ElkLayoutPoint, type ElkLayoutRequest, toTablePoints, } from './elkGraph';
+export { type ElkPlacement, isElkPlacement } from './elkLayoutOptions';
+/**
+ * Where every table goes under the placement the author picked. ELK runs on a
+ * worker and only there, because laying a large schema out holds a thread for
+ * long enough to stop the editor drawing.
+ *
+ * @example
+ * const points = await createElkLayout(createElkLayoutRequest(state, placement));
+ */
+export declare function createElkLayout(request: ElkLayoutRequest): Promise<ElkLayoutPoint[]>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,9 +1,16 @@
 import { FC } from '@dineug/r-html';
-export type ExportSceneProps = {};
+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;
+};
 /**
- * The whole canvas box on one layer, with no culling and no zoom. An exported
- * image is not a picture of the screen, so nothing here reads the scroll, the
- * zoom or the viewport the editor's own scene is placed with.
+ * 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

@@ -1,20 +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, zoom and selection cannot
- * reach the image, which is the whole difference between this and a screenshot.
+ * 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, }: DocumentSceneOptions): Promise<DocumentScene>;
+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

@@ -22,3 +22,4 @@ export declare class ExportPngService {
     render(request: ExportPngRequest): Promise<RenderPngResult>;
     private createToWidth;
 }
+//# sourceMappingURL=exportPngService.d.ts.map

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

@@ -28,6 +28,12 @@ export type DocumentPngOptions = {
      */
     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
@@ -38,11 +44,12 @@ export type DocumentPngOptions = {
     onProgress?: (progress: ExportPngProgress) => void;
 };
 /**
- * A png of the whole canvas box, whatever the editor is scrolled or zoomed to.
- * The scene is drawn again from the document rather than read off the screen,
- * which is what makes the image the same however the editor is being viewed.
+ * 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, onResolutionReduced, onProgress, }: DocumentPngOptions): Promise<Blob>;
+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

@@ -19,3 +19,4 @@ export declare const CANVAS_SIDE_MAX = 32767;
  * 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

@@ -12,6 +12,8 @@ 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;
@@ -32,6 +34,7 @@ export type RenderPngResult = {
  * @example
  * const { blob } = await renderDocumentPng({ doc, theme, pixelRatio: 1, toWidth });
  */
-export declare function renderDocumentPng({ doc, theme, pixelRatio, toWidth, }: RenderPngRequest & {
+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

@@ -25,3 +25,4 @@ export declare function createOffscreenToWidth(): ToWidth | null;
 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,9 +7,12 @@ export type GCIds = {
     indexColumnIds: string[];
     memoIds: string[];
 };
+/** 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 an inline worker
- * import is a second copy of this whole service in the bundle.
+ * 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(): SchemaGCService | null;
+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/shiki/index.d.ts

@@ -0,0 +1,10 @@
+import { ShikiService } from './shikiService';
+import * as Comlink from 'comlink';
+export type { ShikiService } from './shikiService';
+/**
+ * The highlighter the code panels read, built on the first panel that asks for
+ * one and kept for the session. Shiki and its grammars live behind the worker
+ * boundary, so a host that builds none is answered with null and plain text.
+ */
+export declare function getShikiService(): Comlink.Remote<ShikiService> | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/services/shiki/shiki.shared-worker.d.ts

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

package/dist/services/shiki/shikiService.d.ts

@@ -0,0 +1,18 @@
+import { Lang } from '../../constants/language';
+/**
+ * Shiki behind the one method the code panels call, instantiated in the shared
+ * worker and nowhere else. The grammars are exactly what constants/language.ts
+ * maps a Language onto, imported one by one so the worker carries no others.
+ *
+ * @example
+ * const html = await new ShikiService().codeToHtml('select 1', { lang: 'sql' });
+ */
+export declare class ShikiService {
+    private highlighter;
+    constructor();
+    codeToHtml(code: string, { lang, theme }: {
+        lang: Lang;
+        theme?: 'dark' | 'light';
+    }): Promise<string>;
+}
+//# sourceMappingURL=shikiService.d.ts.map

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

@@ -4,3 +4,4 @@
  * 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

@@ -2,3 +2,4 @@ export declare const TextFontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe
 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. */
 export declare const fontsStyle: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=fonts.styles.d.ts.map

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

@@ -3,3 +3,4 @@
  * 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

@@ -4,3 +4,4 @@
  * 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

@@ -13,3 +13,4 @@ export declare const typography: {
 };
 /** 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

@@ -71,3 +71,4 @@ 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

@@ -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,10 @@ 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;
+/**
+ * Takes selection off an element for the length of a gesture and hands back the
+ * undo. A press allowed to start one lets the browser promote the drag to a
+ * native one, which swallows the mouseup the gesture was waiting for.
+ */
+export declare function suppressSelection(el: HTMLElement): () => void;
+//# 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

@@ -68,3 +68,4 @@ export type NudgeMemo = {
  * here, so this runs once per sort.
  */
 export declare function diffTableBoxes(cache: SortCache, obstacles: Obstacles): DirtyBox[] | null;
+//# sourceMappingURL=incremental.d.ts.map

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

@@ -170,3 +170,4 @@ export declare function nextSortEpoch(): void;
  * route from this sort the stub ends are unknown, so the padding carries them.
  */
 export declare function getRouteBBox(relationship: Relationship, strokeWidth?: number): BBox;
+//# sourceMappingURL=index.d.ts.map

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

@@ -2,3 +2,4 @@ import { Point } from '../../internal-types';
 import { NudgeMemo } from './incremental';
 import { Obstacles } from './route';
 export declare function nudgeRoutes(routes: Map<string, Point[]>, obstacles: Obstacles, endpoints: Map<string, [string, string]>, memo?: NudgeMemo): void;
+//# sourceMappingURL=nudge.d.ts.map

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

@@ -7,3 +7,4 @@ export declare function getRelationshipPath(relationship: Relationship): Relatio
  * construction, so each contributes its far end and nothing else.
  */
 export declare function toPathD(segments: Array<[Point, Point]>): string;
+//# sourceMappingURL=pathFinding.d.ts.map

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

@@ -25,3 +25,4 @@ export declare function countBlocked(points: Point[], obstacles: Obstacles, skip
  * nothing is feasible — a connector always has to be drawn.
  */
 export declare function routeOrthogonal(m: Point, mDirection: number, l: Point, lDirection: number, obstacles: Obstacles, skipA: string, skipB: string): Point[];
+//# sourceMappingURL=route.d.ts.map

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

@@ -1,2 +1,3 @@
 import { RootState } from '../../engine/state';
 export declare function relationshipSort(state: RootState): void;
+//# sourceMappingURL=sort.d.ts.map

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

@@ -34,3 +34,4 @@ export declare function stubEnds(relationship: Relationship): StubEnds;
  * decorations and the routed polyline.
  */
 export declare const GUIDE_START: number;
+//# sourceMappingURL=stub.d.ts.map