@dineug/erd-editor 3.4.0 → 3.6.0

package/dist/internal-types/index.d.ts

@@ -37,3 +37,4 @@ export type Ctx = Parameters<typeof useContext>[0];
 export type DeepPartial<T> = T extends string | number | bigint | boolean | null | undefined | symbol ? T | undefined : T extends Array<infer ArrayType> ? Array<DeepPartial<ArrayType>> : T extends ReadonlyArray<infer ArrayType> ? ReadonlyArray<ArrayType> : {
     [K in keyof T]?: DeepPartial<T[K]>;
 };
+//# sourceMappingURL=index.d.ts.map

package/dist/konva/batchDraw.d.ts

@@ -0,0 +1,42 @@
+import { Layer } from 'konva/lib/Layer';
+/**
+ * The commit counter the host's epoch scoped reconcile reads. It advances once
+ * per flush and never on a deferred hop, so one commit reconciles a parent at
+ * most once however many hops the fixed point took.
+ */
+export declare function currentEpoch(): number;
+/**
+ * Registers work that settles the scene before a commit draws it. The host
+ * reconciles its ledger here, which is what makes the flush the one boundary
+ * where the konva tree and the ledger are known to agree.
+ */
+export declare function onBeforeFlush(listener: () => void): () => void;
+/**
+ * Arms the gate without naming a layer, for a change that has to reach the
+ * fixed point but nothing to draw yet. The arming mark counts as dirt itself,
+ * so the commit always lands at least one hop later than the write.
+ */
+export declare function requestFlush(): void;
+/**
+ * Records that a layer needs redrawing and arms the gate. A layer a Tween has
+ * claimed is parked instead, and the end of that window hands it back.
+ */
+export declare function markDirty(layer: Layer): void;
+/**
+ * Hands the draw authority for one layer to a Tween, whose animation frame
+ * draws it. Windows count rather than latch, because one FLIP tweens many
+ * nodes of a layer and each of them opens and closes its own.
+ */
+export declare function beginAnimation(layer: Layer): void;
+/**
+ * Closes one Tween window and, with the last one on a layer, hands the marks
+ * parked meanwhile back to the gate as a single re-arm.
+ */
+export declare function endAnimation(layer: Layer): void;
+/**
+ * Resolves once the scene has settled. An open Tween window anywhere defers
+ * the answer to the end of that window, an armed gate to its flush, and an
+ * idle gate answers at once so a call after a flush never hangs.
+ */
+export declare function whenDrawn(): Promise<void>;
+//# sourceMappingURL=batchDraw.d.ts.map

package/dist/konva/host.d.ts

@@ -0,0 +1,30 @@
+import { DOMTemplateLiterals, HostAdapter } from '@dineug/r-html';
+import { Stage } from 'konva/lib/Stage';
+/**
+ * The name the minimap Stage carries, and the whole reach of the id ban below.
+ * An id scan over Konva.stages is ambiguous the moment two stages spell one id,
+ * so ids belong to the main canvas and the minimap locates by name.
+ */
+export declare const MINIMAP_STAGE_NAME = "minimap";
+/**
+ * What the marker bench reads. A reconcile gone quadratic is invisible from
+ * outside the host, so the counters name the shape of the work itself rather
+ * than a wall clock.
+ */
+export interface HostStats {
+    reconcile: number;
+    scan: number;
+    attach: number;
+    drop: number;
+    order: number;
+    setZIndex: number;
+}
+export declare const hostStats: HostStats;
+export declare function resetHostStats(): void;
+export declare const konvaAdapter: HostAdapter;
+/** Spelt out rather than inferred: the inferred one names an r-html internal. */
+type KonvaTag = (strings: TemplateStringsArray, ...values: any[]) => DOMTemplateLiterals;
+export declare const konva: KonvaTag;
+export declare function renderKonva(stage: Stage, templateLiterals?: DOMTemplateLiterals | null): void;
+export {};
+//# sourceMappingURL=host.d.ts.map

package/dist/konva/jsx-types.test-d.d.ts

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

package/dist/konva/scene/columnDropTarget.d.ts

@@ -0,0 +1,14 @@
+import { RootState } from '../../engine/state';
+import { Point } from '../../internal-types';
+export type ColumnDropTarget = {
+    tableId: string;
+    columnId: string;
+    index: number;
+};
+/**
+ * The row a column drag would drop on, in canvas coordinates, or null over a
+ * header, over bare canvas and past the last row. Arithmetic on the rects the
+ * scene lays rows out with, never a hit canvas read, which costs a frame.
+ */
+export declare function findColumnDropTarget(state: RootState, point: Point): ColumnDropTarget | null;
+//# sourceMappingURL=columnDropTarget.d.ts.map

package/dist/konva/scene/contentBounds.d.ts

@@ -0,0 +1,29 @@
+import { RootState } from '../../engine/state';
+import { Rect } from './metrics';
+/** The smallest box holding both. */
+export declare function unionRect(a: Rect, b: Rect): Rect;
+/** A table and the point it is about to be moved to, named before the move is dispatched. */
+export type TableMove = {
+    id: string;
+    x: number;
+    y: number;
+};
+/**
+ * The box every table and memo of the document fits inside, in scene units, or
+ * null for a document holding none. Computed afresh on every call: the state is
+ * one mutable proxy written in place, so a cache keyed on it never sees a move.
+ */
+export declare function getContentRect(state: RootState): Rect | null;
+/**
+ * One box per table and memo, each table at the point named for it. The reader
+ * that asks which entity is nearest needs them apart, where the box below folds
+ * them together, and both are the same pass over the document.
+ */
+export declare function getContentRects(state: RootState, moves?: ReadonlyArray<TableMove>): Rect[];
+/**
+ * The content rect as it will stand once each table named is at its point. The
+ * placement centres the view on where its tables land in the very dispatch that
+ * moves them, so it has to know the box before any reducer has run.
+ */
+export declare function getContentRectAfter(state: RootState, moves: ReadonlyArray<TableMove>): Rect | null;
+//# sourceMappingURL=contentBounds.d.ts.map

package/dist/konva/scene/konvaFlip.d.ts

@@ -0,0 +1,19 @@
+import { Node as KonvaNode } from 'konva/lib/Node';
+/** The 0.3s transform transition Table.styles gave the dom column-row-move. */
+export declare const FLIP_DURATION = 0.3;
+export type KonvaFlip = {
+    /**
+     * Records where the nodes are now and arms the invert for the commit that
+     * follows. Called before dispatching the change that moves them.
+     */
+    snapshot(): void;
+    /** Ends every running tween at once and hands its layer back to the gate. */
+    cancel(): void;
+};
+/**
+ * FLIP over konva's own Tween, for a reorder the scene has already committed.
+ * The tween owns the draw for the layer it runs on, and every way one can end —
+ * finish, reset, cancel, timeout — hands that authority back exactly once.
+ */
+export declare function createKonvaFlip(nodes: () => KonvaNode[]): KonvaFlip;
+//# sourceMappingURL=konvaFlip.d.ts.map

package/dist/konva/scene/metrics.d.ts

@@ -0,0 +1,30 @@
+import { RootState } from '../../engine/state';
+import { Memo, Table } from '../../internal-types';
+import { ColumnWidth } from '../../utils/calcTable';
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * The box a table occupies in schema coordinates. The size is the one the
+ * relationship sort measures anchors against, so a scene node and the connectors
+ * reaching it cannot disagree about where an edge is.
+ */
+export declare function getTableRect(state: RootState, table: Table): Rect;
+/**
+ * The cell widths a table's rows are laid out against. The total here and the
+ * width in getTableRect are the same sum reached by two routes, the box through
+ * the sort's cache and this fresh, which is the split the DOM scene drew with.
+ */
+export declare function getTableWidths(state: RootState, table: Table): ColumnWidth;
+/**
+ * One column row, taken apart from the same sum calcTableHeight adds up: the
+ * rows start below the header inside the table's inset, and each is one
+ * COLUMN_HEIGHT tall.
+ */
+export declare function getColumnRect(state: RootState, table: Table, index: number): Rect;
+/** The box a memo occupies, sash and header included. */
+export declare function getMemoRect(memo: Memo): Rect;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/konva/scene/renderScene.d.ts

@@ -0,0 +1,35 @@
+import { DOMTemplateLiterals } from '@dineug/r-html';
+import { Stage } from 'konva/lib/Stage';
+import { AppContext } from '../../components/appContext';
+import { Theme } from '../../themes/tokens';
+/**
+ * What konva accepts as a Stage container. Read off the constructor so this
+ * module names no DOM type of its own, which is what lets it be imported in a
+ * realm that has none.
+ */
+type StageContainer = NonNullable<ConstructorParameters<typeof Stage>[0]['container']>;
+export type RenderSceneOptions = {
+    app: AppContext;
+    container: StageContainer;
+    scene: DOMTemplateLiterals;
+    width: number;
+    height: number;
+    /**
+     * The palette to install for this Stage. Left out, the scene resolves the
+     * theme through whatever DOM ancestor the container hangs under, which is
+     * what an editor's own canvas wants and what a realm without one has none of.
+     */
+    theme?: Theme;
+};
+export type RenderedScene = {
+    stage: Stage;
+    destroy: () => void;
+};
+/**
+ * One Stage, one scene, one provider. The provider goes up before the render
+ * because a component resolves its context on its first pass, and it targets
+ * what the host resolves to, so provider and consumers meet on one object.
+ */
+export declare function renderScene({ app, container, scene, width, height, theme, }: RenderSceneOptions): RenderedScene;
+export {};
+//# sourceMappingURL=renderScene.d.ts.map

package/dist/konva/scene/viewFreeze.d.ts

@@ -0,0 +1,20 @@
+import { RootState } from '../../engine/state';
+import { Point } from '../../internal-types';
+import { Rect } from './metrics';
+/**
+ * Holds the content rect and the origin where they stand, so everything a drag
+ * is watched against, the scroll ranges, both scrollbars and the minimap,
+ * stands still together while it lasts and moves together on the drop.
+ */
+export declare function freezeView(root: RootState): void;
+export declare function thawView(root: RootState): void;
+export declare function isViewFrozen(root: RootState): boolean;
+/** The content rect a drag began with while one holds this store's view, else the live one. */
+export declare function getViewContentRect(root: RootState): Rect | null;
+/**
+ * The origin a drag began from while one holds this store's view, else null.
+ * The scroll range keeps it inside its hull for the drag's duration, so the
+ * thumb a drag scales against cannot shrink under the pointer as the origin closes in.
+ */
+export declare function getFrozenOrigin(root: RootState): Point | null;
+//# sourceMappingURL=viewFreeze.d.ts.map

package/dist/konva/scene/viewport.d.ts

@@ -0,0 +1,45 @@
+import { RootState } from '../../engine/state';
+import { Memo, Point, Relationship, Settings, Table } from '../../internal-types';
+import { Rect } from './metrics';
+export type CullingRect = Rect;
+/** The origin and the zoom every scene layer is placed with. */
+export type SceneTransform = Pick<Settings, 'originX' | 'originY' | 'zoomLevel'>;
+export type CullingRectOptions = SceneTransform & {
+    viewportWidth: number;
+    viewportHeight: number;
+};
+/**
+ * Where a scene layer sits on the stage, so screen equals scene times the zoom
+ * plus this. The document stores it directly: settings.originX and originY are
+ * the screen point scene (0, 0) lands on, and nothing else enters.
+ */
+export declare function getSceneOrigin({ originX, originY }: SceneTransform): Point;
+/** Where a scene point lands on the stage, the placement above read forwards. */
+export declare function toScreenPoint(transform: SceneTransform, point: Point): Point;
+/** The scene point under a point on the stage, that same placement inverted. */
+export declare function toScenePoint(transform: SceneTransform, point: Point): Point;
+/**
+ * The origin that puts a scene point under a point on the stage, the placement
+ * solved for its own offset. A jump to a table names where the table should
+ * land and asks this for the view that lands it there.
+ */
+export declare function getOriginToPlace(zoomLevel: number, scene: Point, screen: Point): Point;
+/**
+ * What is on screen with a screen's worth of margin on every side, read back
+ * through the very origin getSceneOrigin places the layer at. The margin is
+ * measured in viewport pixels, never in the document, which is not the screen.
+ */
+export declare function createCullingRect(options: CullingRectOptions): CullingRect;
+/** The culling rect for the editor's current origin, zoom and viewport. */
+export declare function getCullingRect(state: RootState): CullingRect;
+/** Inclusive overlap: a box touching the rect along an edge is still drawn. */
+export declare function intersects(rect: Rect, other: Rect): boolean;
+export declare function isTableVisible(rect: CullingRect, state: RootState, table: Table): boolean;
+export declare function isMemoVisible(rect: CullingRect, memo: Memo): boolean;
+/**
+ * A connector is kept for its whole reach, not for its routed polyline: the
+ * route holds neither the anchors nor the cardinality decorations, and either
+ * can be on screen with every routed point off it.
+ */
+export declare function isRelationshipVisible(rect: CullingRect, relationship: Relationship, strokeWidth?: number): boolean;
+//# sourceMappingURL=viewport.d.ts.map

package/dist/konva/testHandle.d.ts

@@ -0,0 +1,23 @@
+import { Stage } from 'konva/lib/Stage';
+/**
+ * Live Konva stages keyed by the role their owner registers them under, so a
+ * spec can reach the main canvas and the minimap independently.
+ */
+export type StageRegistry = Record<string, Stage>;
+/**
+ * Publishes the registry as __erdStages on the global object and returns it,
+ * so the e2e fixture and the browser-mode specs can read a stage before the
+ * first one mounts. Returns undefined outside dev and test.
+ */
+export declare function installStageTestHandle(): StageRegistry | undefined;
+/**
+ * Adds a stage to the registry under name, creating the registry first when a
+ * stage mounts before the fixture installs the handle.
+ */
+export declare function registerStage(name: string, stage: Stage): void;
+/**
+ * Drops one stage's claim on a name on unmount. The name goes with the last
+ * claim on it, and until then it names whichever stage is still up.
+ */
+export declare function unregisterStage(name: string, stage: Stage): void;
+//# sourceMappingURL=testHandle.d.ts.map

package/dist/konva/theme.d.ts

@@ -0,0 +1,32 @@
+import { Theme } from '../themes/tokens';
+/**
+ * What one theme token resolved to, looked up by its custom property name. The
+ * type names no dom, so the same resolution runs off a computed style here and
+ * off a posted record in a realm that has none.
+ */
+export type ThemeVariableReader = (name: string) => string | null | undefined;
+/** One palette as custom property names to values, plain enough to post. */
+export type ThemeVariables = Record<string, string>;
+/**
+ * The palette a scene paints from. A token the reader has no answer for keeps
+ * the fallback, which is the same rule the emitted var() carries, so a stage
+ * without a stylesheet above it paints the preset rather than nothing.
+ */
+export declare function resolveTheme(fallback: Theme, read: ThemeVariableReader): Theme;
+/** Reads a palette back out of a record some dom realm captured. */
+export declare const fromThemeVariables: (variables: ThemeVariables) => ThemeVariableReader;
+/**
+ * What the cascade settled each token on, captured off one element. Custom
+ * properties inherit and substitute at computed value time, so an override from
+ * a rule anywhere above the host arrives here already applied.
+ */
+export declare function readThemeVariables(host: Element): ThemeVariables;
+/** The palette the host element resolves to, css overrides included. */
+export declare const resolveHostTheme: (host: Element, fallback: Theme) => Theme;
+/**
+ * Calls back when a css override above the host could have moved. It watches
+ * the two vectors that leave a dom trace, a stylesheet in head and a class or
+ * inline style on the host or an ancestor; a cssom insertRule leaves none.
+ */
+export declare function observeThemeOverrides(host: Element, onChange: () => void): () => void;
+//# sourceMappingURL=theme.d.ts.map

package/dist/konva/workerDomStubs.d.ts

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