@dineug/erd-editor 3.4.0 → 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/styles/colorPicker.style.d.ts

@@ -1,10 +1,6 @@
 /**
- * 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;

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

@@ -1,4 +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'";
-/** 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;

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

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

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

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

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

@@ -11,5 +11,5 @@ 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;

package/dist/themes/tokens.d.ts

@@ -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

@@ -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.
  */

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

@@ -94,18 +94,9 @@ export declare const isDirection: (value: string) => boolean;
 export declare const PATH_HEIGHT = 30;
 export declare const PATH_END_HEIGHT: number;
 /**
- * The cardinality decoration, measured outward from the anchor.
- *
- * The four are one shape and cannot be set independently: the second tick and
- * the ring share a centre at `LINE_SIZE + LINE_HEIGHT`, the guide line starts
- * where the longest stroke ends at `LINE_HEIGHT * 2 + 3`, and the ring has to
- * clear the first tick behind it and the guide line in front of it, which puts
- * its radius between those two.
- *
- * Scaled to 0.7 of what they were, so a decoration reaches 25px out rather than
- * 35px. `RELATIONSHIP_STROKE_WIDTH` thinned the connector; leaving the notation
- * at its old size would have made the crow's foot the heaviest thing on the
- * canvas.
+ * 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;
@@ -114,50 +105,34 @@ 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
- * are placed. Without this every path on a side turns at the same `x` (or `y`),
- * so their first segments run down one another no matter how far apart the
- * anchors are spread.
+ * 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. Growing the stub without limit would walk
- * a busy side's paths ever further from the table; wrapping keeps the longest
- * stub at `PATH_END_HEIGHT + 3 * STUB_STEP` while leaving four slots — at least
- * four anchor pitches apart — between any two that share a corridor.
+ * 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`: the cardinality decorations reach that far
- * out from the anchor and the guide line is drawn from there to the stub, so a
- * shorter stub draws that line backwards. It is not derived from it. 36 is where
- * the routing was measured, and letting it follow the decorations down to 26
- * when they shrank took the medium corpus from 168px of collinear overlap to
- * 484px — two tables facing each other closer than `2 * MIN_STUB` turn in
- * earlier, and the routing bench found them sharing a corridor for 316px.
+ * 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.
- *
- * Anchors used to be spread over the whole edge, so two relationships on a tall
- * table splayed hundreds of pixels apart and converged again. Capping the pitch
- * keeps a side's anchors together as a group; the side is only filled when it
- * genuinely has that many relationships.
+ * 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 drawn as a
- * 45-degree cut rather than a right angle.
- *
- * Each cut is clamped to half of the shorter run it touches, so this is a ceiling
- * rather than a length: a short run keeps its right angle instead of losing the
- * whole of itself to two cuts. Two connectors turning the same way in
- * neighbouring lanes stay `NUDGE_GAP` apart through the corner, so a bundle bends
- * as a set of concentric cuts rather than converging on one.
+ * 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;
@@ -165,3 +140,33 @@ export declare function setStubSlots(relationship: Relationship, slots: readonly
 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

@@ -1,3 +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]>): void;
+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

@@ -2,10 +2,8 @@ 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 — they come from a polyline — so
- * each one contributes its far end and nothing else.
+ * 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

@@ -15,18 +15,13 @@ 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.
- *
- * This is the hot function of the whole router: every candidate is scored with
- * it, and the nudge pass calls it twice per lane it tries. The polyline's own
- * bounding box is computed once and used to skip tables outright — a connector
- * spans a small part of the canvas, so most tables fail it. Every segment's box
- * sits inside the polyline's, so a table the polyline's box misses is a table
- * every segment's cheap reject would have missed too; the count is unchanged.
+ * 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
+ * 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

@@ -1,28 +1,17 @@
 import { Point, Relationship } from '../../internal-types';
 /**
- * Where a connector turns away from its anchor.
- *
- * Shared because two callers need the same answer: `pathFinding` draws from it,
- * and `relationshipSort` routes from it. Deriving it twice would let the routed
- * polyline and the guide line drift apart by a slot's worth of stub.
- */
-/**
- * Slot zero keeps the historical `PATH_END_HEIGHT`, so a relationship that never
- * went through `relationshipSort` draws exactly as it did before.
+ * 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: with a stub on each side, a gap of twice
- * the stub puts both turning points on the same spot and the connector vanishes,
- * and a smaller gap inverts it so the path runs backwards through both tables.
- * Nothing stops two tables being that close — the editor allows them to overlap.
+ * 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
+ * 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.
  */

package/dist/utils/emitter.d.ts

@@ -18,6 +18,7 @@ declare const InternalActionType: {
     readonly mouseTrackerEnd: "mouseTrackerEnd";
     readonly openDiffViewer: "openDiffViewer";
     readonly duplicateDragStart: "duplicateDragStart";
+    readonly dragSelectStart: "dragSelectStart";
 };
 type InternalActionType = ValuesType<typeof InternalActionType>;
 type InternalActionMap = {
@@ -55,6 +56,10 @@ type InternalActionMap = {
         tableIds: string[];
         memoIds: string[];
     } | void;
+    [InternalActionType.dragSelectStart]: {
+        x: number;
+        y: number;
+    };
 };
 type ListenerRecord = {
     [P in keyof InternalActionMap]: (action: Action<P, InternalActionMap>) => void;
@@ -181,4 +186,15 @@ export declare const duplicateDragStartAction: {
     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 {};

package/dist/utils/focus.d.ts

@@ -2,6 +2,6 @@ import { FocusTable, FocusType, SharedFocus } from '../engine/modules/editor/sta
 export declare function isFocus(focusTable: Pick<FocusTable, 'tableId' | 'columnId' | 'focusType'> | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
 export declare const isSelectColumn: (focusTable: FocusTable | null, tableId: string, columnId: string) => boolean;
 export declare function isEdit(focusTable: FocusTable | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
-export declare function lastCursorFocus(input: HTMLInputElement): void;
+export declare function lastCursorFocus(input: HTMLInputElement | HTMLTextAreaElement): void;
 export declare const toSharedFocus: (focusTable: FocusTable | null) => SharedFocus | null;
 export declare const toSharedFocusKey: (focus: SharedFocus | null) => string;