@dineug/erd-editor 3.6.0 → 3.8.0

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,10 @@
 import { GeneratorAction } from '../../generator.actions';
-export declare const changeZoomLevelAction$: (value: number) => GeneratorAction;
-export declare const streamZoomLevelAction$: (value: number) => GeneratorAction;
+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 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