@dineug/erd-editor 3.3.1 → 3.5.0

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

@@ -0,0 +1,9 @@
+import { FC } from '@dineug/r-html';
+export type ExportSceneProps = {};
+/**
+ * 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.
+ */
+declare const ExportScene: FC<ExportSceneProps>;
+export default ExportScene;

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

@@ -0,0 +1,20 @@
+import { Stage } from 'konva/lib/Stage';
+import { Theme } from '../../themes/tokens';
+export type DocumentSceneOptions = {
+    doc: string;
+    theme: Theme;
+    toWidth: (text: string) => number;
+};
+export type DocumentScene = {
+    stage: Stage;
+    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.
+ *
+ * @example
+ * const scene = await renderDocumentScene({ doc, theme, toWidth });
+ */
+export declare function renderDocumentScene({ doc, theme, toWidth, }: DocumentSceneOptions): Promise<DocumentScene>;

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

@@ -0,0 +1,24 @@
+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;
+}

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

@@ -0,0 +1,48 @@
+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;
+    /**
+     * 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 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.
+ *
+ * @example
+ * const blob = await createDocumentPng({ doc: toJson(store.state), theme, toWidth });
+ */
+export declare function createDocumentPng({ doc, theme, toWidth, pixelRatio, onResolutionReduced, onProgress, }: DocumentPngOptions): Promise<Blob>;

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

@@ -0,0 +1,21 @@
+/**
+ * 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;

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

@@ -0,0 +1,37 @@
+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;
+};
+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, toWidth, }: RenderPngRequest & {
+    toWidth: ToWidth;
+}): Promise<RenderPngResult>;

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

@@ -0,0 +1,27 @@
+/** 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;

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

@@ -7,4 +7,9 @@ export type GCIds = {
     indexColumnIds: string[];
     memoIds: string[];
 };
+/**
+ * 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.
+ */
 export declare function getSchemaGCService(): SchemaGCService | null;

package/dist/services/shikiService.d.ts

@@ -1,6 +1,6 @@
 export type ShikiService = {
     codeToHtml(code: string, { lang, theme, }: {
-        lang: 'sql' | 'typescript' | 'graphql' | 'csharp' | 'java' | 'kotlin' | 'scala';
+        lang: 'sql' | 'typescript' | 'graphql' | 'csharp' | 'java' | 'kotlin' | 'scala' | 'go' | 'python';
         theme?: 'dark' | 'light';
     }): Promise<string>;
 };

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

@@ -1 +1,6 @@
-export declare function createColorPickerStyle(): HTMLStyleElement;
+/**
+ * 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;

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

@@ -1,3 +1,4 @@
 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'";
-export declare function createFontsStyle(): HTMLStyleElement;
+/** Global, not scoped: :host is the shadow host, which no component class matches. */
+export declare const fontsStyle: import('@dineug/r-html').CSSTemplateLiterals;

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

@@ -1 +1,5 @@
-export declare function createResetStyle(): HTMLStyleElement;
+/**
+ * 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;

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

@@ -1 +1,6 @@
-export declare function createScrollbarStyle(): HTMLStyleElement;
+/**
+ * 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;

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

@@ -11,4 +11,5 @@ export declare const typography: {
     readonly normal: import('@dineug/r-html').CSSTemplateLiterals;
     readonly paragraph: import('@dineug/r-html').CSSTemplateLiterals;
 };
-export declare function createTypographyStyle(): HTMLStyleElement;
+/** Global, not scoped: :host is the shadow host, which no component class matches. */
+export declare const typographyStyle: import('@dineug/r-html').CSSTemplateLiterals;

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

@@ -1783,7 +1783,7 @@ export declare const AccentColor: {
     readonly sky: "sky";
 };
 export type AccentColor = ValuesType<typeof AccentColor>;
-export declare const AccentColorList: ("gray" | "gold" | "bronze" | "brown" | "yellow" | "amber" | "orange" | "tomato" | "red" | "ruby" | "crimson" | "pink" | "plum" | "purple" | "violet" | "iris" | "indigo" | "blue" | "cyan" | "teal" | "jade" | "green" | "grass" | "lime" | "mint" | "sky")[];
+export declare const AccentColorList: ("ruby" | "gray" | "gold" | "bronze" | "brown" | "yellow" | "amber" | "orange" | "tomato" | "red" | "crimson" | "pink" | "plum" | "purple" | "violet" | "iris" | "indigo" | "blue" | "cyan" | "teal" | "jade" | "green" | "grass" | "lime" | "mint" | "sky")[];
 export type ThemeOptions = {
     appearance: Appearance;
     grayColor: GrayColor;

package/dist/themes/tokens.d.ts

@@ -45,8 +45,8 @@ export type Theme = {
     minimapViewportBorderHover: string;
     toastBackground: string;
     toastBorder: string;
-    dargSelectBackground: string;
-    dargSelectBorder: string;
+    dragSelectBackground: string;
+    dragSelectBorder: string;
     scrollbarTrack: string;
     scrollbarThumb: string;
     scrollbarThumbHover: string;
@@ -66,4 +66,8 @@ 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;

package/dist/utils/calcTable.d.ts

@@ -1,6 +1,13 @@
 import { EngineContext } from '../engine/context';
 import { RootState } from '../engine/state';
 import { Table } from '../internal-types';
+export declare function getWidthGeneration(): number;
+/**
+ * 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.
+ */
+export declare function invalidateTableWidths(): void;
 export declare function calcTableWidths(table: Table, { settings: { show, maxWidthComment }, collections }: RootState): ColumnWidth;
 export type ColumnWidth = {
     width: number;

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

@@ -0,0 +1,2 @@
+import { Point } from '../../internal-types';
+export declare function chamferPolyline(points: Point[], size: number): Point[];

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

@@ -0,0 +1,70 @@
+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;

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

@@ -1,4 +1,4 @@
-import { Point, RelationshipPoint, ValuesType } from '../../internal-types';
+import { Point, Relationship, ValuesType } from '../../internal-types';
 export declare const DirectionName: {
     readonly left: "left";
     readonly right: "right";
@@ -78,15 +78,6 @@ export type RelationshipPath = {
         startCircle: Circle;
     };
 };
-export type RelationshipMarginPoint = {
-    xArray: number[];
-    yArray: number[];
-};
-export type RelationshipOrder = {
-    start: RelationshipPoint;
-    end: RelationshipPoint;
-    distance: number;
-};
 export type ObjectPoint = {
     width: number;
     height: number;
@@ -102,7 +93,80 @@ export type ObjectPoint = {
 export declare const isDirection: (value: string) => boolean;
 export declare const PATH_HEIGHT = 30;
 export declare const PATH_END_HEIGHT: number;
-export declare const PATH_LINE_HEIGHT = 35;
-export declare const LINE_SIZE = 10;
-export declare const LINE_HEIGHT = 16;
-export declare const CIRCLE_HEIGHT = 26;
+/**
+ * The cardinality decoration, measured outward from the anchor. The four are one
+ * shape and cannot be set independently: the ring shares a centre with the
+ * second tick and has to clear both the first tick and the guide line.
+ */
+export declare const LINE_SIZE = 7;
+export declare const LINE_HEIGHT = 11;
+export declare const CIRCLE_HEIGHT: number;
+export declare const CIRCLE_RADIUS = 6;
+export declare const PATH_LINE_HEIGHT: number;
+/**
+ * How far apart the corridors of two relationships leaving the same table side
+ * sit. Without it every path on a side turns at the same coordinate and their
+ * first segments run down one another however far the anchors are spread.
+ */
+export declare const STUB_STEP = 12;
+/**
+ * Corridors repeat every fourth slot. An unbounded stub walks a busy side's
+ * paths ever further from the table; wrapping caps the longest one and still
+ * leaves four slots between any two that share a corridor.
+ */
+export declare const STUB_CYCLE = 4;
+/**
+ * The shortest a stub may be clamped to. It has to clear PATH_LINE_HEIGHT or the
+ * guide line is drawn backwards, but it is not derived from it: this is where
+ * the routing was measured, and following the decorations down cost overlap.
+ */
+export declare const MIN_STUB = 36;
+/**
+ * The widest gap allowed between two anchors on the same table side. Capping the
+ * pitch keeps a side's anchors together as a group, so a tall table's edge is
+ * only filled when it genuinely has that many relationships.
+ */
+export declare const ANCHOR_MAX_PITCH = 120;
+/** Keeps the outermost anchor of a side clear of the table's corners. */
+export declare const ANCHOR_EDGE_INSET = 12;
+/**
+ * How far back from a corner a connector turns when the corner is cut to 45
+ * degrees. A ceiling rather than a length: each cut is clamped to half the
+ * shorter run it touches, so a short run keeps its right angle.
+ */
+export declare const ROUTE_CHAMFER = 8;
+export declare function setStubSlots(relationship: Relationship, slots: readonly [number, number]): void;
+/** Falls back to slot zero, which reproduces the pre-stagger geometry. */
+export declare function getStubSlots(relationship: Relationship): readonly [number, number];
+export declare function setRoute(relationship: Relationship, points: Point[]): void;
+export declare function getRoute(relationship: Relationship): Point[] | undefined;
+/**
+ * How far a connector reaches past its anchor, whichever decoration is furthest
+ * out. The ring shares a centre with the second tick, so its outer edge and the
+ * start of the guide line are the two candidates.
+ */
+export declare const ROUTE_BBOX_REACH: number;
+/**
+ * The longest stub a slot can ask for. It bounds where the turning points of an
+ * unrouted relationship can be, which is the only thing the route itself would
+ * have told us.
+ */
+export declare const MAX_STUB: number;
+export type BBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Opens a sort, retiring every route box the previous one wrote. Identity
+ * outlives a sort, so the stamp a route carries is what separates a box for the
+ * current routes from one the next sort has already replaced.
+ */
+export declare function nextSortEpoch(): void;
+/**
+ * Everywhere a relationship can be drawn, for a culling test that must not lose
+ * a connector whose anchors are on screen and whose route is not. Without a
+ * route from this sort the stub ends are unknown, so the padding carries them.
+ */
+export declare function getRouteBBox(relationship: Relationship, strokeWidth?: number): BBox;

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

@@ -0,0 +1,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;

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

@@ -1,3 +1,9 @@
-import { Relationship } from '../../internal-types';
+import { Point, Relationship } from '../../internal-types';
 import { RelationshipPath } from '.';
 export declare function getRelationshipPath(relationship: Relationship): RelationshipPath;
+/**
+ * The routing polyline as one d, so a connector is a single element whatever the
+ * router and the corner cuts made of it. The segments are contiguous by
+ * construction, so each contributes its far end and nothing else.
+ */
+export declare function toPathD(segments: Array<[Point, Point]>): string;

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

@@ -0,0 +1,27 @@
+import { RootState } from '../../engine/state';
+import { Point } from '../../internal-types';
+export type Obstacles = {
+    ids: string[];
+    left: Float64Array;
+    top: Float64Array;
+    right: Float64Array;
+    bottom: Float64Array;
+};
+/**
+ * Every table in the document, not only those carrying a relationship: a table
+ * with no relationships at all still blocks the view.
+ */
+export declare function collectObstacles(state: RootState): Obstacles;
+/** Liang–Barsky, with no divisions until a slab actually clips. */
+export declare function segmentHitsBox(ax: number, ay: number, bx: number, by: number, left: number, top: number, right: number, bottom: number): boolean;
+/**
+ * How many tables a polyline passes through, ignoring the two it connects. The
+ * hot function of the router, so the polyline's own box is computed once to skip
+ * tables outright; every segment's box sits inside it, so the count is the same.
+ */
+export declare function countBlocked(points: Point[], obstacles: Obstacles, skipA: string, skipB: string): number;
+/**
+ * The cheapest orthogonal polyline from m to l, or a two-bend fallback when
+ * 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[];

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

@@ -0,0 +1,36 @@
+import { Point, Relationship } from '../../internal-types';
+/**
+ * Slot zero keeps the historical PATH_END_HEIGHT, so a relationship that never
+ * went through relationshipSort draws exactly as it did before.
+ */
+export declare function stubFor(slot: number): number;
+/**
+ * The axis-aligned distance between two anchors that point at each other, or
+ * null when they do not. Only this arrangement can collapse: a gap of twice the
+ * stub puts both turning points on one spot, and a smaller gap inverts the path.
+ */
+export declare function facingGap(start: Relationship['start'], end: Relationship['end']): number | null;
+/**
+ * Below roughly 2 * MIN_STUB the two cardinality decorations already overlap
+ * each other, which no stub length can fix; the clamp stops short of making it
+ * worse by drawing the guide line backwards.
+ */
+export declare function clampStub(stub: number, gap: number | null): number;
+export type StubEnds = {
+    /** Turning point on the start side. */
+    m: Point;
+    /** Turning point on the end side. */
+    l: Point;
+    startStub: number;
+    endStub: number;
+};
+export declare function isHorizontal(direction: number): direction is 1 | 2;
+/** +1 when the anchor's outward normal points right or down. */
+export declare function outwardSign(direction: number): 1 | -1;
+/** The two points a route has to join, given the anchors and their slots. */
+export declare function stubEnds(relationship: Relationship): StubEnds;
+/**
+ * Where the guide line begins — the short run between the cardinality
+ * decorations and the routed polyline.
+ */
+export declare const GUIDE_START: number;

package/dist/utils/emitter.d.ts

@@ -17,6 +17,8 @@ declare const InternalActionType: {
     readonly mouseTrackerStart: "mouseTrackerStart";
     readonly mouseTrackerEnd: "mouseTrackerEnd";
     readonly openDiffViewer: "openDiffViewer";
+    readonly duplicateDragStart: "duplicateDragStart";
+    readonly dragSelectStart: "dragSelectStart";
 };
 type InternalActionType = ValuesType<typeof InternalActionType>;
 type InternalActionMap = {
@@ -50,6 +52,14 @@ type InternalActionMap = {
     [InternalActionType.openDiffViewer]: {
         value: string;
     };
+    [InternalActionType.duplicateDragStart]: {
+        tableIds: string[];
+        memoIds: string[];
+    } | void;
+    [InternalActionType.dragSelectStart]: {
+        x: number;
+        y: number;
+    };
 };
 type ListenerRecord = {
     [P in keyof InternalActionMap]: (action: Action<P, InternalActionMap>) => void;
@@ -165,4 +175,26 @@ export declare const openDiffViewerAction: {
     toString(): string;
     type: string;
 };
+export declare const duplicateDragStartAction: {
+    (payload: void | {
+        tableIds: string[];
+        memoIds: string[];
+    }): AnyAction<void | {
+        tableIds: string[];
+        memoIds: string[];
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const dragSelectStartAction: {
+    (payload: {
+        x: number;
+        y: number;
+    }): AnyAction<{
+        x: number;
+        y: number;
+    }>;
+    toString(): string;
+    type: string;
+};
 export {};

package/dist/utils/file/exportFile.d.ts

@@ -1,3 +1,4 @@
+import { DocumentPngOptions } from '../../services/export-png';
 type ExportOptions = {
     fileName: string;
 };
@@ -5,5 +6,13 @@ type ExportFileCallback = (blob: Blob, options: ExportOptions) => void;
 export declare function setExportFileCallback(callback: ExportFileCallback | null): void;
 export declare function exportJSON(json: string, name?: string): void;
 export declare function exportSchemaSQL(sql: string, name?: string): void;
-export declare function exportPNG(root: HTMLElement, name?: string): void;
+/**
+ * Writes the whole document out as an image. What is on screen is not an input:
+ * the scene is rendered again off screen from the document alone, so the file a
+ * reader opens does not depend on where the author had scrolled or zoomed to.
+ *
+ * @example
+ * exportPNG({ doc: toJson(store.state), theme, toWidth }, databaseName);
+ */
+export declare function exportPNG(options: DocumentPngOptions, name?: string): Promise<void>;
 export {};