@dineug/erd-editor 3.10.0 → 4.1.0

package/dist/engine/modules/table-group/atom.actions.d.ts

@@ -0,0 +1,238 @@
+import { ReducerType } from './actions';
+export declare const addTableGroupAction: {
+    (payload: {
+        id: string;
+        color?: string;
+        ui: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            zIndex: number;
+        };
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        color?: string;
+        ui: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            zIndex: number;
+        };
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const moveTableGroupAction: {
+    (payload: {
+        movementX: number;
+        movementY: number;
+        ids: string[];
+    }): import('@dineug/r-html').AnyAction<{
+        movementX: number;
+        movementY: number;
+        ids: string[];
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const moveToTableGroupAction: {
+    (payload: {
+        id: string;
+        x: number;
+        y: number;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        x: number;
+        y: number;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const removeTableGroupAction: {
+    (payload: {
+        id: string;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const resizeTableGroupAction: {
+    (payload: {
+        id: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const changeTableGroupNameAction: {
+    (payload: {
+        id: string;
+        value: string;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        value: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const changeTableGroupColorAction: {
+    (payload: {
+        id: string;
+        color: string;
+        prevColor: string;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        color: string;
+        prevColor: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const changeTableGroupZIndexAction: {
+    (payload: {
+        id: string;
+        zIndex: number;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        zIndex: number;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const tableGroupReducers: {
+    "tableGroup.add": ReducerType<"tableGroup.add">;
+    "tableGroup.move": ReducerType<"tableGroup.move">;
+    "tableGroup.moveTo": ReducerType<"tableGroup.moveTo">;
+    "tableGroup.remove": ReducerType<"tableGroup.remove">;
+    "tableGroup.resize": ReducerType<"tableGroup.resize">;
+    "tableGroup.changeName": ReducerType<"tableGroup.changeName">;
+    "tableGroup.changeColor": ReducerType<"tableGroup.changeColor">;
+    "tableGroup.changeZIndex": ReducerType<"tableGroup.changeZIndex">;
+};
+export declare const actions: {
+    addTableGroupAction: {
+        (payload: {
+            id: string;
+            color?: string;
+            ui: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+                zIndex: number;
+            };
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            color?: string;
+            ui: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+                zIndex: number;
+            };
+        }>;
+        toString(): string;
+        type: string;
+    };
+    moveTableGroupAction: {
+        (payload: {
+            movementX: number;
+            movementY: number;
+            ids: string[];
+        }): import('@dineug/r-html').AnyAction<{
+            movementX: number;
+            movementY: number;
+            ids: string[];
+        }>;
+        toString(): string;
+        type: string;
+    };
+    moveToTableGroupAction: {
+        (payload: {
+            id: string;
+            x: number;
+            y: number;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            x: number;
+            y: number;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    removeTableGroupAction: {
+        (payload: {
+            id: string;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    resizeTableGroupAction: {
+        (payload: {
+            id: string;
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    changeTableGroupNameAction: {
+        (payload: {
+            id: string;
+            value: string;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            value: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    changeTableGroupColorAction: {
+        (payload: {
+            id: string;
+            color: string;
+            prevColor: string;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            color: string;
+            prevColor: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    changeTableGroupZIndexAction: {
+        (payload: {
+            id: string;
+            zIndex: number;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            zIndex: number;
+        }>;
+        toString(): string;
+        type: string;
+    };
+};
+//# sourceMappingURL=atom.actions.d.ts.map

package/dist/engine/modules/table-group/generator.actions.d.ts

@@ -0,0 +1,111 @@
+import { AnyAction } from '@dineug/r-html';
+import { GeneratorAction } from '../../generator.actions';
+import { RootState } from '../../state';
+import { Table } from '../../../internal-types';
+import { Rect } from '../../../konva/scene/metrics';
+/** What a new group starts with besides its rect: no name and no color unless given. */
+export type NewTableGroupFields = {
+    name?: string;
+    color?: string;
+};
+/**
+ * Adds a group drawn over the canvas: the tables in no group whose centre lies
+ * in the rect join it, and a table in another group stays where it is.
+ *
+ * @example
+ * store.dispatch(addTableGroupAction$({ x: 0, y: 0, width: 600, height: 400 }));
+ */
+export declare const addTableGroupAction$: (rect: Rect, fields?: NewTableGroupFields) => GeneratorAction;
+/**
+ * Adds a group around the tables given, or the selected ones, their bounds and
+ * the padding its rect: each joins it, leaving any group it was in. No table
+ * the document lists, and nothing is added.
+ *
+ * @example
+ * store.dispatch(addTableGroupFromTablesAction$());
+ */
+export declare const addTableGroupFromTablesAction$: (tableIds?: string[], fields?: NewTableGroupFields) => GeneratorAction;
+/**
+ * Removes the group named, or every selected one the document lists, each with
+ * its members' groupId cleared in the same dispatch, so one undo brings back
+ * the group and its members together.
+ */
+export declare const removeTableGroupAction$: (id?: string) => GeneratorAction;
+/**
+ * The tables a move of groups and tables carries: the tables given and every
+ * member of those groups, a table both given and a member once.
+ */
+export declare function getCarriedTableIds(state: RootState, groupIds: string[], tableIds: string[]): string[];
+/**
+ * The drag step of groups and the tables they carry (getCarriedTableIds): each
+ * group and each table by the same step, tagged as drags.
+ */
+export declare function toMoveTableGroupActions(groupIds: string[], tableIds: string[], movementX: number, movementY: number): AnyAction[];
+/**
+ * Moves groups by a step in scene units, their member tables with them, in one
+ * dispatch: moves are relative, so a peer's concurrent move adds up.
+ *
+ * @example
+ * store.dispatch(moveTableGroupAction$(['g1'], 40, 0));
+ */
+export declare const moveTableGroupAction$: (ids: string[], movementX: number, movementY: number) => GeneratorAction;
+/**
+ * Puts the tables in the group, or in none for '': a group the document does
+ * not list, and nothing is sent, nor for a table already where it goes.
+ *
+ * @example
+ * store.dispatch(setTableGroupAction$(['users', 'orders'], 'g1'));
+ */
+export declare const setTableGroupAction$: (tableIds: string[], groupId: string) => GeneratorAction;
+/** A table a drop judges, the group it lands in, '' for none, and that group's box, null for none. */
+export type TableGroupDrop = {
+    table: Table;
+    groupId: string;
+    box: Rect | null;
+};
+/**
+ * The box each group showed as a drag began, by group id, held for the drag's
+ * length: a member that grew past the stored rect stays in the box the reader
+ * saw while its centre does, though only its own padding drew the box there.
+ */
+export type HeldTableGroupBoxes = ReadonlyMap<string, Rect>;
+/**
+ * Where a drop puts each selected table no selected group carries: in the topmost group whose box
+ * without them, and for a group the drag leaves standing the box it held too, holds its centre, or
+ * in none. With groups hidden or no table to judge, a drag of groups alone, it reads no box.
+ */
+export declare function getTableGroupDrops(state: RootState, held?: HeldTableGroupBoxes | null): TableGroupDrop[];
+/**
+ * Ends a drag of the selection: each table getTableGroupDrops judges, given the boxes the drag held,
+ * joins the group it landed in or leaves its own, tagged as the drag, so the history closes the
+ * membership into the drag's undo entry; its undo reads prevValue.
+ *
+ * @example
+ * store.dispatch(dropTablesIntoGroupsAction$(held));
+ */
+export declare const dropTablesIntoGroupsAction$: (held?: HeldTableGroupBoxes | null) => GeneratorAction;
+/**
+ * Selects a group, alone unless $mod, and draws it over every other group and its tables over every
+ * other table and memo in their own order, as a press on a table raises it. Otherwise a group drag
+ * would lift its tables over the rest and drop them back under it.
+ */
+export declare const selectTableGroupAction$: (id: string, $mod: boolean) => GeneratorAction;
+/**
+ * Selects the group's member tables alone, the group itself left out, so what
+ * a table command reaches next is its tables.
+ *
+ * @example
+ * store.dispatch(selectTableGroupTablesAction$('g1'));
+ */
+export declare const selectTableGroupTablesAction$: (id: string) => GeneratorAction;
+export declare const actions$: {
+    addTableGroupAction$: (rect: Rect, fields?: NewTableGroupFields) => GeneratorAction;
+    addTableGroupFromTablesAction$: (tableIds?: string[], fields?: NewTableGroupFields) => GeneratorAction;
+    removeTableGroupAction$: (id?: string) => GeneratorAction;
+    moveTableGroupAction$: (ids: string[], movementX: number, movementY: number) => GeneratorAction;
+    setTableGroupAction$: (tableIds: string[], groupId: string) => GeneratorAction;
+    dropTablesIntoGroupsAction$: (held?: HeldTableGroupBoxes | null) => GeneratorAction;
+    selectTableGroupAction$: (id: string, $mod: boolean) => GeneratorAction;
+    selectTableGroupTablesAction$: (id: string) => GeneratorAction;
+};
+//# sourceMappingURL=generator.actions.d.ts.map

package/dist/engine/modules/table-group/history.d.ts

@@ -0,0 +1,13 @@
+import { PushStreamHistory, PushUndoHistory } from '../../history.actions';
+export declare const tableGroupPushUndoHistoryMap: {
+    "tableGroup.add": PushUndoHistory;
+    "tableGroup.remove": PushUndoHistory;
+    "tableGroup.changeName": PushUndoHistory;
+    "tableGroup.moveTo": PushUndoHistory;
+    "tableGroup.resize": PushUndoHistory;
+};
+export declare const tableGroupPushStreamHistoryMap: {
+    "tableGroup.move": PushStreamHistory;
+    "tableGroup.changeColor": PushStreamHistory;
+};
+//# sourceMappingURL=history.d.ts.map

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

@@ -55,16 +55,22 @@ export declare class PeerStoreError extends Error {
 }
 export type PeerStore = {
     readonly editorId: string;
-    /** The document as the element would save it. */
+    /** The document as the element would save it, in the form a file holds. */
     readonly value: string;
+    /**
+     * The document as this peer holds it, removed entities included, for another
+     * peer's setInitialValue, so an undo of a removal restores the entity whole there.
+     */
+    readonly runtimeValue: string;
     /** The live state, for readers that serialize it another way. */
     readonly state: RootState;
     readonly isReadonly: boolean;
     readonly isDestroyed: boolean;
     setReadonly: (readonly: boolean) => void;
     /**
-     * Replaces the document and forgets every undo entry and label with it,
-     * since those were taken against the old one. The one reseed operation.
+     * Replaces the document and forgets every undo entry, label and register with
+     * it, since those were taken against the old one, and once subscribed asks the
+     * other peers for their registers again. The one reseed operation.
      */
     setInitialValue: (value: string) => void;
     mergeClock: (version: number) => void;

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

@@ -12,16 +12,19 @@ type InternalActionMap = {
     [InternalActionType.change]: ReplicationChange;
 };
 /**
- * What a change hands its listeners: the document serialized, and whether the
- * change actions since the last change, or since the load, left it byte for
- * byte as it was, as a scroll or a zoom the file does not save does.
+ * What a change hands its listeners: the document in the form a file holds,
+ * and whether the change actions since the last change, or since the load,
+ * left that form byte for byte as it was, as a scroll under its lock does.
  */
 export type ReplicationChange = {
     value: string;
     changed: boolean;
 };
 export type ReplicationStore = {
+    /** The document in the form a file holds. */
     readonly value: string;
+    /** The document as the replica holds it, removed entities included, to seed a peer. */
+    readonly runtimeValue: string;
     /**
      * A change comes 200 ms after the last change action, even one that left the
      * value as it was (changed false): a hub waits for each as a save, and a host

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

@@ -1,6 +1,10 @@
 import { AnyAction } from '@dineug/r-html';
 import { MonoTypeOperatorFunction, Observable } from 'rxjs';
-type Regroup = [string, Array<string> | ReadonlyArray<string>];
+/**
+ * A group's key and the types it takes, and optionally a tag that brings any
+ * action carrying it into the group whatever its type.
+ */
+type Regroup = [string, Array<string> | ReadonlyArray<string>, number?];
 /** Runs on a stream group's batches; each value it emits closes the buffer. */
 export type StreamBufferOperator = MonoTypeOperatorFunction<Array<AnyAction>>;
 export declare const groupByStreamActions: (streamActionTypes: Array<string> | ReadonlyArray<string>, regroups?: Regroup[], bufferClosingNotifierOperator?: StreamBufferOperator) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;

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

@@ -0,0 +1,8 @@
+import { AnyAction } from '@dineug/r-html';
+import { Observable } from 'rxjs';
+/**
+ * Drops each setting action whose lock is on, read as the batch passes: it
+ * moved the screen alone, since the file keeps the value the lock holds.
+ */
+export declare const lockIgnoreFilter: (getLockSettings: () => number) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+//# sourceMappingURL=lockIgnoreFilter.d.ts.map

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

@@ -14,6 +14,8 @@ export type RxStore = Store & {
      * unless the store was created with manualStreamFlush.
      */
     flushStreamBuffers: () => void;
+    /** Whether the editor is readonly now, which drops every edit of the document. */
+    getReadonly: () => boolean;
 };
 export type RxStoreOptions = {
     getReadonly?: () => boolean;

package/dist/engine/settle.d.ts

@@ -0,0 +1,9 @@
+import { EngineContext } from './context';
+import { RootState } from './state';
+/**
+ * Writes every value a document derives from what it holds: the key marks, the
+ * widths as this store measures them, the anchors, the routes where it draws,
+ * and each relationship's flags. A load runs it before its reducer returns.
+ */
+export declare function settleDocument(state: RootState, ctx: EngineContext): void;
+//# sourceMappingURL=settle.d.ts.map

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

@@ -1,13 +1,5 @@
-import { EngineContext } from './context';
-import { RootState } from './state';
 import { Store } from './store';
 export declare function createHooks(store: Store): {
     destroy: () => void;
 };
-/**
- * Writes at once what the hooks a load wakes write over the next 10 ms, which
- * then find nothing left to write, so a replica measuring changes from its load
- * does not take them for an edit.
- */
-export declare function settleLoad(state: RootState, ctx: EngineContext): void;
 //# sourceMappingURL=store-hooks.d.ts.map