@dineug/erd-editor 3.5.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

@@ -39,3 +39,4 @@ export declare function endAnimation(layer: Layer): void;
  * 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

@@ -27,3 +27,4 @@ type KonvaTag = (strings: TemplateStringsArray, ...values: any[]) => DOMTemplate
 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

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

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

@@ -11,3 +11,4 @@ export type ColumnDropTarget = {
  * 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

@@ -16,3 +16,4 @@ export type KonvaFlip = {
  * 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

@@ -27,3 +27,4 @@ export declare function getTableWidths(state: RootState, table: Table): ColumnWi
 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

@@ -32,3 +32,4 @@ export type RenderedScene = {
  */
 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

@@ -2,29 +2,35 @@ import { RootState } from '../../engine/state';
 import { Memo, Point, Relationship, Settings, Table } from '../../internal-types';
 import { Rect } from './metrics';
 export type CullingRect = Rect;
-/** The scroll, the zoom and the canvas box every scene layer is placed with. */
-export type SceneTransform = Pick<Settings, 'width' | 'height' | 'scrollLeft' | 'scrollTop' | 'zoomLevel'>;
+/** 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 css transform it replaces scaled about the middle of the canvas
- * box, so half the shrink travels with the scroll instead of riding on the scale.
+ * 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({ width, height, scrollLeft, scrollTop, zoomLevel, }: SceneTransform): Point;
+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 canvas box, which is not the screen.
+ * 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 scroll, zoom, canvas and viewport. */
+/** 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;
@@ -36,3 +42,4 @@ export declare function isMemoVisible(rect: CullingRect, memo: Memo): boolean;
  * 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

@@ -20,3 +20,4 @@ export declare function registerStage(name: string, stage: Stage): void;
  * 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

@@ -29,3 +29,4 @@ export declare const resolveHostTheme: (host: Element, fallback: Theme) => Theme
  * 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

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