@dineug/erd-editor 3.7.0 → 3.8.0

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