@dineug/erd-editor 3.7.0 → 3.9.0

package/dist/engine/modules/editor/view.actions.d.ts

@@ -0,0 +1,270 @@
+import { ReducerType } from './actions';
+import { Editor, ViewKind } from './state';
+/** Drops the view, which is what any replacement of the document owes it. */
+export declare function clearViews(editor: Editor): void;
+export declare const viewOpenAction: {
+    (payload: {
+        kind: ViewKind;
+        centerIds?: string[];
+    }): import('@dineug/r-html').AnyAction<{
+        kind: ViewKind;
+        centerIds?: string[];
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewCloseAction: {
+    (payload: {
+        kind: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        kind: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewScrollToAction: {
+    (payload: {
+        originX: number;
+        originY: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        originX: number;
+        originY: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewStreamScrollToAction: {
+    (payload: {
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewChangeZoomLevelAction: {
+    (payload: {
+        value: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        value: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewStreamZoomLevelAction: {
+    (payload: {
+        value: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        value: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewMoveTableAction: {
+    (payload: {
+        ids: string[];
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        ids: string[];
+        movementX: number;
+        movementY: number;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewSetLayoutAction: {
+    (payload: {
+        kind: ViewKind;
+        positions: Record<string, import('../../../internal-types').Point>;
+    }): import('@dineug/r-html').AnyAction<{
+        kind: ViewKind;
+        positions: Record<string, import('../../../internal-types').Point>;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewChangeShowModeAction: {
+    (payload: {
+        value: import('./state').ShowMode;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        value: import('./state').ShowMode;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewSetCentersAction: {
+    (payload: {
+        tableIds: string[];
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        tableIds: string[];
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const changeVisualizationModeAction: {
+    (payload: {
+        value: import('./state').VisualizationMode;
+    }): import('@dineug/r-html').AnyAction<{
+        value: import('./state').VisualizationMode;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const viewReducers: {
+    "editor.viewOpen": ReducerType<"editor.viewOpen">;
+    "editor.viewClose": ReducerType<"editor.viewClose">;
+    "editor.viewScrollTo": ReducerType<"editor.viewScrollTo">;
+    "editor.viewStreamScrollTo": ReducerType<"editor.viewStreamScrollTo">;
+    "editor.viewChangeZoomLevel": ReducerType<"editor.viewChangeZoomLevel">;
+    "editor.viewStreamZoomLevel": ReducerType<"editor.viewStreamZoomLevel">;
+    "editor.viewMoveTable": ReducerType<"editor.viewMoveTable">;
+    "editor.viewSetLayout": ReducerType<"editor.viewSetLayout">;
+    "editor.viewChangeShowMode": ReducerType<"editor.viewChangeShowMode">;
+    "editor.viewSetCenters": ReducerType<"editor.viewSetCenters">;
+    "editor.changeVisualizationMode": ReducerType<"editor.changeVisualizationMode">;
+};
+export declare const viewActions: {
+    viewOpenAction: {
+        (payload: {
+            kind: ViewKind;
+            centerIds?: string[];
+        }): import('@dineug/r-html').AnyAction<{
+            kind: ViewKind;
+            centerIds?: string[];
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewCloseAction: {
+        (payload: {
+            kind: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            kind: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewScrollToAction: {
+        (payload: {
+            originX: number;
+            originY: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            originX: number;
+            originY: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewStreamScrollToAction: {
+        (payload: {
+            movementX: number;
+            movementY: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            movementX: number;
+            movementY: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewChangeZoomLevelAction: {
+        (payload: {
+            value: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewStreamZoomLevelAction: {
+        (payload: {
+            value: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewMoveTableAction: {
+        (payload: {
+            ids: string[];
+            movementX: number;
+            movementY: number;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            ids: string[];
+            movementX: number;
+            movementY: number;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewSetLayoutAction: {
+        (payload: {
+            kind: ViewKind;
+            positions: Record<string, import('../../../internal-types').Point>;
+        }): import('@dineug/r-html').AnyAction<{
+            kind: ViewKind;
+            positions: Record<string, import('../../../internal-types').Point>;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewChangeShowModeAction: {
+        (payload: {
+            value: import('./state').ShowMode;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            value: import('./state').ShowMode;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    viewSetCentersAction: {
+        (payload: {
+            tableIds: string[];
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            tableIds: string[];
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    changeVisualizationModeAction: {
+        (payload: {
+            value: import('./state').VisualizationMode;
+        }): import('@dineug/r-html').AnyAction<{
+            value: import('./state').VisualizationMode;
+        }>;
+        toString(): string;
+        type: string;
+    };
+};
+//# sourceMappingURL=view.actions.d.ts.map

package/dist/engine/modules/editor/view.d.ts

@@ -0,0 +1,28 @@
+import { RootState } from '../../state';
+import { GeometrySource, ViewSource } from '../../../utils/draw-relationship/geometrySource';
+import { SceneView, ViewKind } from './state';
+/**
+ * The view the reader stands in, or null in the document itself. A Flow view
+ * counts only while the visualization tab shows it, so one kept across tabs is
+ * open but not stood in.
+ */
+export declare const getActiveView: (state: RootState) => SceneView | null;
+/**
+ * Whether a scene is drawing the view of the kind given: an open Flow view
+ * only while its tab shows Flow. One kept across tabs is open but unseen, and
+ * nothing reads its geometry until it is back.
+ */
+export declare const isViewShown: (state: RootState, kind: ViewSource) => boolean;
+/**
+ * The view a scene drawn from the source given reads, open or not: the slot
+ * of that kind, and null for the document. A scene reads its own slot and
+ * never the active one, so an export of the document is never drawn from a view.
+ */
+export declare const getSourceView: (state: RootState, source: GeometrySource) => SceneView | null;
+/**
+ * A view just opened: nothing placed yet, the neutral placement a fit will
+ * replace, and the display its centers ask for. Narrowed to a few tables it
+ * opens on the key rows; over the whole document it draws name boxes.
+ */
+export declare function createSceneView(kind: ViewKind, centerIds?: string[]): SceneView;
+//# sourceMappingURL=view.d.ts.map

package/dist/engine/modules/editor/view.generator.actions.d.ts

@@ -0,0 +1,24 @@
+import { GeneratorAction } from '../../generator.actions';
+import { SelectType } from './state';
+/**
+ * The centers a focus from the ERD takes: every table the selection holds, and
+ * the one a menu was raised over alone when the selection does not hold it, so
+ * a group is focused as one exactly as it is dragged as one. A memo is no center.
+ *
+ * @example
+ * store.dispatch(focusFlowTableAction$(focusCentersOf(editor.selectedMap, tableId)));
+ */
+export declare function focusCentersOf(selectedMap: Record<string, SelectType>, tableId?: string): string[];
+/**
+ * Stands the reader on the tables given in the Flow view: the visualization
+ * tab comes up on Flow, a view is opened if none is, and what it shows narrows
+ * to those centers and their neighbours. No ids and it stands.
+ *
+ * @example
+ * store.dispatch(focusFlowTableAction$(['orders']));
+ */
+export declare const focusFlowTableAction$: (tableIds: string[]) => GeneratorAction;
+export declare const viewActions$: {
+    focusFlowTableAction$: (tableIds: string[]) => GeneratorAction;
+};
+//# sourceMappingURL=view.generator.actions.d.ts.map

package/dist/engine/modules/settings/atom.actions.d.ts

@@ -1,6 +1,7 @@
 import { Viewport } from '../editor/state';
 import { RootState } from '../../state';
 import { Point } from '../../../internal-types';
+import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
 import { ActionMap, ActionType, ReducerType } from './actions';
 import { ScrollRange } from './scrollRange';
 export type { ScrollRange } from './scrollRange';
@@ -42,7 +43,7 @@ export declare const hasViewport: ({ width, height }: Viewport) => boolean;
  * edge meeting the near edge of the screen to its near edge meeting the far
  * one. An empty document and an unmeasured screen have no travel to offer.
  */
-export declare function getContentScrollRanges(state: RootState): ScrollRanges;
+export declare function getContentScrollRanges(state: RootState, source?: GeometrySource): ScrollRanges;
 /**
  * The origin a load settles on: kept where the file put it while any of the
  * content is drawn there, else pulled to where a screen's worth of it, or all
@@ -54,14 +55,14 @@ export declare function getOpeningOrigin(state: RootState): Point;
  * content's own range widened to hold the origin where it stands and, while a
  * drag holds the view, the origin it started from, so it never shifts under the drag.
  */
-export declare function getScrollRanges(state: RootState): ScrollRanges;
+export declare function getScrollRanges(state: RootState, source?: GeometrySource): ScrollRanges;
 export type ScrollMovement = ActionMap[typeof ActionType.streamScrollTo];
 /**
  * The step of a thumb or handle drag cut to the hull it is drawn over, so the
  * origin lands on the end of the travel rather than a step past it. An
  * unmeasured screen has no travel to cut against and hands the step back as it is.
  */
-export declare function clampScrollMovement(state: RootState, { movementX, movementY }: ScrollMovement): ScrollMovement;
+export declare function clampScrollMovement(state: RootState, { movementX, movementY }: ScrollMovement, source?: GeometrySource): ScrollMovement;
 export declare const scrollToAction: {
     (payload: {
         originX: number;
@@ -84,6 +85,19 @@ export declare const streamScrollToAction: {
     toString(): string;
     type: string;
 };
+/**
+ * The scroll a scene dispatches lands where that scene reads: the document's
+ * own for the document scene, and the view of the source's kind, named, for a
+ * view scene, so neither of two scenes on one page ever scrolls the other.
+ */
+export declare const sceneScrollToAction: (source: GeometrySource, payload: ActionMap[typeof ActionType.scrollTo]) => import('@dineug/r-html').AnyAction<{
+    originX: number;
+    originY: number;
+}>;
+export declare const sceneStreamScrollToAction: (source: GeometrySource, payload: ScrollMovement) => import('@dineug/r-html').AnyAction<{
+    movementX: number;
+    movementY: number;
+}>;
 export declare const changeShowAction: {
     (payload: {
         show: number;

package/dist/engine/modules/settings/generator.actions.d.ts

@@ -1,8 +1,25 @@
 import { GeneratorAction } from '../../generator.actions';
-export declare const changeZoomLevelAction$: (value: number) => GeneratorAction;
-export declare const streamZoomLevelAction$: (value: number) => GeneratorAction;
+import { Point } from '../../../internal-types';
+import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
+/** The origin it adds the movement to is the one getMovementScrollTo solved against. */
+export declare const changeZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
+export declare const streamZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
+export type PinchZoom = {
+    /** The zoom the pinch has reached, which the store rounds as it lands. */
+    zoomLevel: number;
+    /** Where the pinch is centred now, in the scene box. */
+    screen: Point;
+    /** The scene point the pinch holds, else the one under screen. */
+    scene?: Point;
+};
+/**
+ * A step of a pinch: the zoom it has reached, with the scene point it holds put
+ * under where it is centred now, so two fingers zoom about their midpoint and
+ * pan as it travels. Streamed, so a whole pinch is one undo entry as a wheel is.
+ */
+export declare const pinchZoomAction$: ({ zoomLevel, screen, scene }: PinchZoom, source?: GeometrySource) => GeneratorAction;
 export declare const actions$: {
-    changeZoomLevelAction$: (value: number) => GeneratorAction;
-    streamZoomLevelAction$: (value: number) => GeneratorAction;
+    changeZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
+    streamZoomLevelAction$: (value: number, source?: GeometrySource) => GeneratorAction;
 };
 //# sourceMappingURL=generator.actions.d.ts.map

package/dist/engine/rx-operators/viewActionRedirect.d.ts

@@ -0,0 +1,10 @@
+import { AnyAction } from '@dineug/r-html';
+import { Observable } from 'rxjs';
+import { SceneView } from '../modules/editor/state';
+/**
+ * Turns a scroll or zoom into the view's own while a view is active. Pure by
+ * contract: the chain it sits in is cold with two subscribers, so this runs
+ * twice per emission and must map the same input to the same output untouched.
+ */
+export declare const viewActionRedirect: (getActiveView: () => SceneView | null) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+//# sourceMappingURL=viewActionRedirect.d.ts.map

package/dist/engine/rx-operators/viewIgnoreFilter.d.ts

@@ -0,0 +1,10 @@
+import { AnyAction } from '@dineug/r-html';
+import { Observable } from 'rxjs';
+import { SceneView } from '../modules/editor/state';
+/**
+ * Drops the document edits while a view is active, the way readonlyIgnoreFilter
+ * drops them for a readonly host, so the view a reader stands in never writes
+ * the document under it. A pass tag lets an action through regardless.
+ */
+export declare const viewIgnoreFilter: (getActiveView: () => SceneView | null, passTags?: number[]) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+//# sourceMappingURL=viewIgnoreFilter.d.ts.map

package/dist/engine/rx-store.d.ts

@@ -7,6 +7,7 @@ export type RxStore = Store & {
     undo: () => void;
     redo: () => void;
     history: History;
+    resetHistory: () => void;
     change$: Observable<Array<AnyAction>>;
 };
 export type RxStoreOptions = {

package/dist/engine/tag.d.ts

@@ -4,6 +4,8 @@ export declare const Tag: {
     readonly shared: 1;
     readonly changeOnly: 2;
     readonly following: 4;
+    /** A step a pointer drag streams, where an undo of the same move is one jump. */
+    readonly drag: 8;
 };
 export declare function attachActionTag(tag: number, action: AnyAction): AnyAction;
 export declare function attachActionsTag(tag: number, actions: AnyAction[]): AnyAction[];