@dineug/erd-editor 3.6.0 → 3.8.0

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

@@ -1,5 +1,6 @@
 import { RootState } from '../../engine/state';
 import { Point } from '../../internal-types';
+import { GeometrySource } from '../../utils/draw-relationship/geometrySource';
 export type ColumnDropTarget = {
     tableId: string;
     columnId: string;
@@ -10,5 +11,5 @@ export type ColumnDropTarget = {
  * 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;
+export declare function findColumnDropTarget(state: RootState, point: Point, source?: GeometrySource): ColumnDropTarget | null;
 //# sourceMappingURL=columnDropTarget.d.ts.map

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

@@ -1,5 +1,6 @@
 import { RootState } from '../../engine/state';
 import { Rect } from './metrics';
+import { GeometrySource } from '../../utils/draw-relationship/geometrySource';
 /** 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. */
@@ -15,15 +16,21 @@ export type TableMove = {
  */
 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.
+ * The box the scene drawn from a source fits inside: the document's content
+ * rect, or for a view the tables it shows at their view points and no memo,
+ * since a view places none. A view showing nothing has no box.
  */
-export declare function getContentRects(state: RootState, moves?: ReadonlyArray<TableMove>): Rect[];
+export declare function getSceneContentRect(state: RootState, source?: GeometrySource): Rect | null;
+/**
+ * One box per table and memo the source shows, 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 scene.
+ */
+export declare function getContentRects(state: RootState, moves?: ReadonlyArray<TableMove>, source?: GeometrySource): 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;
+export declare function getContentRectAfter(state: RootState, moves: ReadonlyArray<TableMove>, source?: GeometrySource): Rect | null;
 //# sourceMappingURL=contentBounds.d.ts.map

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

@@ -0,0 +1,16 @@
+import { Viewport } from '../../engine/modules/editor/state';
+import { Rect } from './metrics';
+/**
+ * Scene units left around the content when a fit takes it in, so a table at
+ * the edge of what is fitted is not flush against the edge of the screen.
+ */
+export declare const FIT_PADDING = 200;
+/** The closest the placement preview opens at: the whole document is what it is for. */
+export declare const PREVIEW_ZOOM_MAX = 0.7;
+/**
+ * The zoom a fit opens at: the content with its padding fitted into the screen
+ * on both axes, rounded to the two places a zoom is kept to, and held between
+ * the floor every zoom has and a ceiling, the preview's unless a view names its own.
+ */
+export declare function previewZoomLevel(content: Rect, viewport: Viewport, maxZoom?: number): number;
+//# sourceMappingURL=fitZoom.d.ts.map

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

@@ -1,6 +1,7 @@
 import { RootState } from '../../engine/state';
 import { Memo, Table } from '../../internal-types';
 import { ColumnWidth } from '../../utils/calcTable';
+import { GeometrySource } from '../../utils/draw-relationship/geometrySource';
 export type Rect = {
     x: number;
     y: number;
@@ -12,19 +13,19 @@ export type Rect = {
  * 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;
+export declare function getTableRect(state: RootState, table: Table, source?: GeometrySource): 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;
+export declare function getTableWidths(state: RootState, table: Table, source?: GeometrySource): 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.
+ * rows start below the header inside the table's inset, and each is one row
+ * height tall. Both of those come from the source, as they do in that sum.
  */
-export declare function getColumnRect(state: RootState, table: Table, index: number): Rect;
+export declare function getColumnRect(state: RootState, table: Table, index: number, source?: GeometrySource): 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/viewFreeze.d.ts

@@ -1,20 +1,23 @@
 import { RootState } from '../../engine/state';
 import { Point } from '../../internal-types';
 import { Rect } from './metrics';
+import { GeometrySource } from '../../utils/draw-relationship/geometrySource';
+/** One scene among every store on the page: its editor's id and the source it draws from. */
+export declare const sceneKeyOf: (root: RootState, source: GeometrySource) => string;
 /**
  * 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;
+export declare function freezeView(root: RootState, source?: GeometrySource): void;
+export declare function thawView(root: RootState, source?: GeometrySource): void;
+export declare function isViewFrozen(root: RootState, source?: GeometrySource): boolean;
+/** The content rect a drag began with while one holds this scene's view, else the live one. */
+export declare function getViewContentRect(root: RootState, source?: GeometrySource): Rect | null;
 /**
- * The origin a drag began from while one holds this store's view, else null.
+ * The origin a drag began from while one holds this scene'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;
+export declare function getFrozenOrigin(root: RootState, source?: GeometrySource): Point | null;
 //# sourceMappingURL=viewFreeze.d.ts.map

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

@@ -0,0 +1,89 @@
+import { RootState } from '../../engine/state';
+import { Point, Table } from '../../internal-types';
+import { GeometrySource } from '../../utils/draw-relationship/geometrySource';
+/**
+ * The ids a scene drawn from one source shows, each list in document order.
+ * To be read, never changed in place: for the document these are the
+ * document's own arrays, and with no view open the one shared empty set.
+ */
+export type VisibleIds = {
+    tableIds: string[];
+    memoIds: string[];
+    relationshipIds: string[];
+};
+/** The tables a view lights and the relationships between them and what lit them. */
+export type HighlightIds = {
+    tableIds: Set<string>;
+    relationshipIds: Set<string>;
+};
+/**
+ * What a box, a connector, a dot or a name fades to while it sits outside
+ * the lit neighbourhood of a hovered table, so that neighbourhood reads on its
+ * own. One value for the graph and the Flow scene, which fade the same way.
+ */
+export declare const DIM_OPACITY = 0.2;
+/**
+ * Where a table stands in the source given: its own placement in the
+ * document, or the point the view of that kind placed it at. A view that has
+ * not placed it yet shows it where the document has it, until a layout lands.
+ */
+export declare function getTablePoint(state: RootState, table: Table, source?: GeometrySource): Point;
+/**
+ * The same rows for every table at once, walked once over the document. What a
+ * scene hands its cards, since a card asking for its own would walk every link
+ * again, once per card drawn.
+ *
+ * @example
+ * const related = relationshipColumnIdsByTable(state).get(table.id);
+ */
+export declare function relationshipColumnIdsByTable(state: RootState): Map<string, Set<string>>;
+/**
+ * The rows a table shows in the source given, in column order: every row in
+ * the document, and in a view what its show mode says, none, all, or the key
+ * rows, a key row carrying a primary or foreign key flag or ending any relationship.
+ */
+export declare function getVisibleColumnIds(state: RootState, table: Table, source?: GeometrySource): string[];
+/**
+ * What a scene drawn from the source given shows: the whole document, or a
+ * view's centers with their neighbours one relationship out while it stands on
+ * centers and what its layout placed while it stands on none, with no memo and only the joining relationships.
+ */
+export declare function getVisibleIds(state: RootState, source?: GeometrySource): VisibleIds;
+/**
+ * Takes the hover for the view of the source given, or drops it on null. A
+ * null from a scene of another kind leaves the hover alone: a leave on the
+ * document scene beside it is not the view's table leaving the pointer.
+ */
+export declare function setViewHoverTable(root: RootState, tableId: string | null, source?: GeometrySource): void;
+/**
+ * Drops the hover one table holds as it leaves the scene of the source given.
+ * A node culled or unmounted under the pointer sends no mouseleave, and the
+ * entry left behind would light that table until the next hover and hold its view meanwhile.
+ */
+export declare function clearViewHoverTable(root: RootState, tableId: string, source?: GeometrySource): void;
+export declare function getViewHoverTable(root: RootState, source?: GeometrySource): string | null;
+/**
+ * Pins the table in the view of the source given, or lets it go when it is
+ * the one already pinned. A second click on the same card is what releases it,
+ * so the gesture is its own toggle and nothing else has to clear the slot.
+ */
+export declare function setViewPinnedTable(root: RootState, tableId: string, source?: GeometrySource): void;
+/**
+ * Lets go of whatever the view of the source given pinned. The press on the
+ * background that clears a highlight, beside the second press on the card that
+ * took it, both of which are the reader saying the same thing.
+ */
+export declare function clearViewPinnedTable(root: RootState, source?: GeometrySource): void;
+/**
+ * The pin the view of the source given holds. One taken in a view that has
+ * since closed fails the identity below and is never read, which is why only a
+ * reader's own gesture ever clears the slot.
+ */
+export declare function getViewPinnedTable(root: RootState, source?: GeometrySource): string | null;
+/**
+ * What the view of the source given lights: the table hovered, the table
+ * pinned, and for each of those every shown relationship at it and the table
+ * at the other end. A narrowed view rests unlit like the whole document, since its centers seed nothing.
+ */
+export declare function getHighlightIds(state: RootState, source?: GeometrySource): HighlightIds;
+//# sourceMappingURL=viewLayout.d.ts.map

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

@@ -1,6 +1,7 @@
 import { RootState } from '../../engine/state';
 import { Memo, Point, Relationship, Settings, Table } from '../../internal-types';
 import { Rect } from './metrics';
+import { GeometrySource } from '../../utils/draw-relationship/geometrySource';
 export type CullingRect = Rect;
 /** The origin and the zoom every scene layer is placed with. */
 export type SceneTransform = Pick<Settings, 'originX' | 'originY' | 'zoomLevel'>;
@@ -8,6 +9,18 @@ export type CullingRectOptions = SceneTransform & {
     viewportWidth: number;
     viewportHeight: number;
 };
+/**
+ * The placement a reader standing outside every scene means: the active
+ * view's while one is open, else the document's. The zoom generators read
+ * it, since the redirect sends what they dispatch there too.
+ */
+export declare function getActiveTransform(state: RootState): SceneTransform;
+/**
+ * The placement a scene is drawn at: the document's own, or that of the view
+ * of the scene's kind. A view scene whose view is not open falls back to the
+ * document, so it draws something rather than nothing while one is opening.
+ */
+export declare function getSceneTransform(state: RootState, source?: GeometrySource): SceneTransform;
 /**
  * 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
@@ -30,16 +43,16 @@ export declare function getOriginToPlace(zoomLevel: number, scene: Point, 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 origin, zoom and viewport. */
-export declare function getCullingRect(state: RootState): CullingRect;
+/** The culling rect for the scene's current origin, zoom and the editor's viewport. */
+export declare function getCullingRect(state: RootState, source?: GeometrySource): 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 isTableVisible(rect: CullingRect, state: RootState, table: Table, source?: GeometrySource): 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;
+export declare function isRelationshipVisible(rect: CullingRect, relationship: Relationship, strokeWidth?: number, source?: GeometrySource): boolean;
 //# sourceMappingURL=viewport.d.ts.map