@dineug/erd-editor 3.4.0 → 3.6.0

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,34 @@ 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;
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,3 +1,5 @@
 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;
+//# sourceMappingURL=nudge.d.ts.map

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

@@ -2,10 +2,9 @@ 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;
+//# sourceMappingURL=pathFinding.d.ts.map

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

@@ -15,18 +15,14 @@ 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[];
+//# 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

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

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,16 @@ 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 {};
+//# sourceMappingURL=emitter.d.ts.map

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

@@ -1,3 +1,4 @@
+import { DocumentPngOptions } from '../../services/export-png';
 type ExportOptions = {
     fileName: string;
 };
@@ -5,5 +6,14 @@ 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, at the zoom the author is reading
+ * it at. The scene is rendered again off screen rather than captured, so the
+ * file holds the whole document however far it was scrolled away from.
+ *
+ * @example
+ * exportPNG({ doc: toJson(store.state), theme, toWidth, zoomLevel }, databaseName);
+ */
+export declare function exportPNG(options: DocumentPngOptions, name?: string): Promise<void>;
 export {};
+//# sourceMappingURL=exportFile.d.ts.map

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

@@ -13,3 +13,4 @@ export declare function importDBML({ store, emitter }: AppContext): void;
 export declare function importAML({ store, emitter }: AppContext): void;
 export declare function importDiffJSON({ emitter }: AppContext): void;
 export {};
+//# sourceMappingURL=importFile.d.ts.map

package/dist/utils/flipAnimation.d.ts

@@ -8,3 +8,4 @@ export declare class FlipAnimation {
     snapshot(): void;
     play(): void;
 }
+//# sourceMappingURL=flipAnimation.d.ts.map

package/dist/utils/focus.d.ts

@@ -2,6 +2,7 @@ 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;
+//# sourceMappingURL=focus.d.ts.map

package/dist/utils/generator-code/aml.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=aml.d.ts.map

package/dist/utils/generator-code/csharp.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=csharp.d.ts.map

package/dist/utils/generator-code/dbml.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=dbml.d.ts.map

package/dist/utils/generator-code/drizzle.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=drizzle.d.ts.map

package/dist/utils/generator-code/go.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=go.d.ts.map

package/dist/utils/generator-code/graphql.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/utils/generator-code/index.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { Table } from '../../internal-types';
 export declare function createGeneratorCode(state: RootState): string;
 export declare function createGeneratorCodeTable(state: RootState, table: Table): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/generator-code/java.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=java.d.ts.map

package/dist/utils/generator-code/jpa.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=jpa.d.ts.map

package/dist/utils/generator-code/kotlin.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=kotlin.d.ts.map

package/dist/utils/generator-code/scala.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=scala.d.ts.map

package/dist/utils/generator-code/sequelize.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=sequelize.d.ts.map

package/dist/utils/generator-code/sqlalchemy.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=sqlalchemy.d.ts.map

package/dist/utils/generator-code/typeorm.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=typeorm.d.ts.map

package/dist/utils/generator-code/typescript.d.ts

@@ -2,3 +2,4 @@ import { RootState } from '../../engine/state';
 import { FormatTableOptions } from './utils';
 export declare function createCode(state: RootState): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
+//# sourceMappingURL=typescript.d.ts.map

package/dist/utils/generator-code/utils.d.ts

@@ -17,3 +17,4 @@ export declare const hasNRelationship: (value: number) => boolean;
 export declare function getPrimitiveType(dataType: string, database: number): PrimitiveType;
 export declare function getDataTypeHints(database: number): DataTypeHint[];
 export declare function getNameCase(name: string, nameCase: number): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils/globalEmitter.d.ts

@@ -1,2 +1,3 @@
 import { Emitter } from './emitter';
 export declare const globalEmitter: Emitter;
+//# sourceMappingURL=globalEmitter.d.ts.map

package/dist/utils/globalEventObservable.d.ts

@@ -1,16 +1,17 @@
-export declare const keyup$: import('rxjs').Observable<KeyboardEvent>;
-export declare const mousedown$: import('rxjs').Observable<MouseEvent>;
-export declare const mousemove$: import('rxjs').Observable<MouseEvent>;
-export declare const mouseup$: import('rxjs').Observable<MouseEvent>;
-export declare const touchstart$: import('rxjs').Observable<TouchEvent>;
-export declare const touchmove$: import('rxjs').Observable<TouchEvent>;
-export declare const touchend$: import('rxjs').Observable<TouchEvent>;
-export declare const animationFrames$: import('rxjs').Observable<{
+import { Observable } from 'rxjs';
+export declare const keyup$: Observable<KeyboardEvent>;
+export declare const mousedown$: Observable<MouseEvent>;
+export declare const mousemove$: Observable<MouseEvent>;
+export declare const mouseup$: Observable<MouseEvent>;
+export declare const touchstart$: Observable<TouchEvent>;
+export declare const touchmove$: Observable<TouchEvent>;
+export declare const touchend$: Observable<TouchEvent>;
+export declare const animationFrames$: Observable<{
     timestamp: number;
     elapsed: number;
 }>;
-export declare const moveStart$: import('rxjs').Observable<MouseEvent | TouchEvent>;
-export declare const moveEnd$: import('rxjs').Observable<MouseEvent | TouchEvent>;
+export declare const moveStart$: Observable<MouseEvent | TouchEvent>;
+export declare const moveEnd$: Observable<MouseEvent | TouchEvent>;
 export type DragMove = {
     movementX: number;
     movementY: number;
@@ -18,7 +19,7 @@ export type DragMove = {
     y: number;
     event: MouseEvent | TouchEvent;
 };
-export declare const move$: import('rxjs').Observable<{
+export declare const move$: Observable<{
     event: MouseEvent;
     movementX: number;
     movementY: number;
@@ -31,7 +32,7 @@ export declare const move$: import('rxjs').Observable<{
     x: number;
     y: number;
 }>;
-export declare const drag$: import('rxjs').Observable<{
+export declare const drag$: Observable<{
     event: MouseEvent;
     movementX: number;
     movementY: number;
@@ -44,3 +45,4 @@ export declare const drag$: import('rxjs').Observable<{
     x: number;
     y: number;
 }>;
+//# sourceMappingURL=globalEventObservable.d.ts.map

package/dist/utils/icon.d.ts

@@ -1 +1,10 @@
-export declare function getRelationshipIcon(relationshipType: number): string | null;
+import { IconNode } from 'lucide';
+/**
+ * An icon node as an svg data uri, which is what css cursor takes. The glyph
+ * is drawn twice, the halo under the ink, with the caps and joins Icon.tsx puts
+ * on its svg so the cursor matches the menu item.
+ */
+export declare function toCursorImage(node: IconNode, isDarkMode: boolean): string;
+/** The draw-relationship cursor for a relationship type, or null for a type with no glyph. */
+export declare function getRelationshipIcon(relationshipType: number, isDarkMode: boolean): string | null;
+//# sourceMappingURL=icon.d.ts.map

package/dist/utils/index.d.ts

@@ -1,7 +1,8 @@
 import { EntityMeta, Memo, Point, Settings, Table } from '../internal-types';
 export declare const nextZIndex: (tables: Table[], memos: Memo[]) => number;
-export declare function nextPoint({ width, height, zoomLevel, scrollLeft, scrollTop }: Settings, tables: Table[], memos: Memo[]): Point;
+export declare function nextPoint(settings: Settings, tables: Table[], memos: Memo[]): Point;
 export declare const toList: <T>(ids: string[], entities: Record<string, T>) => Array<T>;
 export declare function getDefaultEntityMeta(): EntityMeta;
 export declare function safeRange(a: number, b: number): number[];
 export declare function pascalCase(value?: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/internalEvents.d.ts

@@ -36,3 +36,4 @@ export declare const forwardMoveStartEvent: {
     type: string;
 };
 export {};
+//# sourceMappingURL=internalEvents.d.ts.map

package/dist/utils/keyboard-shortcut/index.d.ts

@@ -26,11 +26,26 @@ export declare const KeyBindingName: {
     readonly tableProperties: "tableProperties";
     readonly zoomIn: "zoomIn";
     readonly zoomOut: "zoomOut";
+    readonly zoomReset: "zoomReset";
+    readonly handTool: "handTool";
+    readonly zenMode: "zenMode";
 };
 export type KeyBindingName = ValuesType<typeof KeyBindingName>;
-export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "primaryKey" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "zoomIn" | "zoomOut")[];
+export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "primaryKey" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
 export type KeyBindingMap = Record<KeyBindingName, ShortcutOption[]>;
 export declare const createKeyBindingMap: () => KeyBindingMap;
 export declare function shortcutToTuple(shortcut?: string): KeyBindingPress[];
 export declare function isMod(event: MouseEvent | TouchEvent | KeyboardEvent): boolean;
+/**
+ * Whether the press still belongs to an IME composition. The browser finishes
+ * the composition on its own, so a binding that fired here would spend a key
+ * the text editor was owed and leave a half-formed syllable behind.
+ */
+export declare function isComposing(event: KeyboardEvent): boolean;
+/**
+ * What a button says it is: its name and the first chord bound to it, since a
+ * command can carry several and a tooltip naming all of them reads as noise.
+ */
+export declare function toShortcutTitle(keyBindingMap: KeyBindingMap, name: string, keyBindingName: KeyBindingName): string;
 export declare function simpleShortcutToString(shortcut?: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/keyboard-shortcut/utils.d.ts

@@ -1,2 +1,3 @@
 export type KeyBindingPress = [string[], string];
 export declare function parseKeybinding(str: string): KeyBindingPress[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils/promise.d.ts

@@ -1,2 +1,3 @@
 export declare const delay: (ms: number) => Promise<void>;
 export declare function closePromise(): [Promise<void>, () => void];
+//# sourceMappingURL=promise.d.ts.map

package/dist/utils/rx-operators/fromCopy.d.ts

@@ -1,3 +1,4 @@
 import { Observable } from 'rxjs';
 import { Emitter } from '../emitter';
 export declare const fromCopy: (emitter: Emitter) => Observable<ClipboardEvent>;
+//# sourceMappingURL=fromCopy.d.ts.map

package/dist/utils/rx-operators/fromDraggable.d.ts

@@ -1 +1,2 @@
 export declare const fromDraggable: (elements: Element[]) => import('rxjs').Observable<DragEvent>;
+//# sourceMappingURL=fromDraggable.d.ts.map

package/dist/utils/rx-operators/fromPaste.d.ts

@@ -1,3 +1,4 @@
 import { Observable } from 'rxjs';
 import { Emitter } from '../emitter';
 export declare const fromPaste: (emitter: Emitter) => Observable<ClipboardEvent>;
+//# sourceMappingURL=fromPaste.d.ts.map

package/dist/utils/rx-operators/fromShadowDraggable.d.ts

@@ -1 +1,2 @@
 export declare const fromShadowDraggable: <R>(elements: HTMLElement[], prepare: (el: HTMLElement) => R) => import('rxjs').Observable<R>;
+//# sourceMappingURL=fromShadowDraggable.d.ts.map

package/dist/utils/rx-operators/takeUnsubscribe.d.ts

@@ -1,2 +1,3 @@
 import { Observable } from 'rxjs';
 export declare const takeUnsubscribe: (callback: () => void) => <T>(source$: Observable<T>) => Observable<T>;
+//# sourceMappingURL=takeUnsubscribe.d.ts.map

package/dist/utils/safeCallback.d.ts

@@ -0,0 +1,5 @@
+type Callback = (...args: any[]) => any;
+/** Calls an optional callback and keeps its exception on the console rather than in the caller. */
+export declare function safeCallback<F extends Callback>(callback?: F | void, ...args: Parameters<F>): any;
+export {};
+//# sourceMappingURL=safeCallback.d.ts.map

package/dist/utils/schema-aml-parser/convert.d.ts

@@ -2,3 +2,4 @@ import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
 import { EngineContext } from '../../engine/context';
 import { AMLModel } from './types';
 export declare function convertToSchema(model: AMLModel, ctx: EngineContext, database: number): ERDEditorSchemaV3;
+//# sourceMappingURL=convert.d.ts.map

package/dist/utils/schema-aml-parser/dataType.d.ts

@@ -1,13 +1,13 @@
 import { AMLModel } from './types';
 /**
- * `enumValues` carries the inline `status post_status(draft, published)`
- * members, which never reach `model.types`. Both entry points take them as a
- * trailing optional argument so `convert.ts` keeps one call site each, and
- * inline members take precedence over anything the name would resolve to.
+ * enumValues carries the inline members, which never reach model.types. Both
+ * entry points take them as a trailing optional argument, and inline members
+ * take precedence over anything the name would resolve to.
  */
 export declare function resolveDataType(typeName: string, database: number, model: AMLModel, enumValues?: string[]): string;
 /**
- * Keeps the members where the column type cannot hold them. Pass `database` to
- * drop it on the dialects whose `ENUM(...)` column already spells them out.
+ * Keeps the members where the column type cannot hold them. Pass database to
+ * drop it on the dialects whose ENUM(...) column already spells them out.
  */
 export declare function enumCommentSuffix(typeName: string, model: AMLModel, database: number, enumValues?: string[]): string;
+//# sourceMappingURL=dataType.d.ts.map

package/dist/utils/schema-aml-parser/index.d.ts

@@ -1,3 +1,4 @@
 import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
 import { EngineContext } from '../../engine/context';
 export declare function schemaAMLParserToSchemaJson(aml: string, ctx: EngineContext, prepare?: (schema: ERDEditorSchemaV3) => ERDEditorSchemaV3): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/schema-aml-parser/parser.d.ts

@@ -1,2 +1,3 @@
 import { AMLParseResult } from './types';
 export declare function parseAMLModel(source: string): AMLParseResult;
+//# sourceMappingURL=parser.d.ts.map

package/dist/utils/schema-aml-parser/tokenizer.d.ts

@@ -10,11 +10,9 @@ export declare const TokenKind: {
     readonly newline: 9;
 };
 /**
- * AML is indentation-sensitive, so every token carries the depth of its line --
- * `-1` when the line is unindented, `0` for the first nesting level. A newline
- * token opens the line that follows it and already holds that line's depth, and
- * the stream always starts with a synthetic one (`value: ''`, `line: 0`), so
- * `parser.ts` reads the first line's depth the same way as every other line's.
+ * AML is indentation-sensitive, so every token carries its line's depth. A
+ * newline token opens the line that follows and holds that line's depth, and a
+ * synthetic one starts the stream so the first line reads like every other.
  */
 export type Token = {
     kind: number;
@@ -23,3 +21,4 @@ export type Token = {
     depth: number;
 };
 export declare function tokenize(source: string): Token[];
+//# sourceMappingURL=tokenizer.d.ts.map