@dineug/erd-editor 3.3.1 → 3.5.0

package/dist/components/visualization/createVisualization.d.ts

@@ -1,9 +1,68 @@
+import { Simulation } from 'd3-force';
 import { RootState } from '../../engine/state';
-type Props = {
-    onDragStart: () => void;
-    onDragEnd: () => void;
-    onStartPreview: (event: MouseEvent, tableId: string | null, columnId: string | null) => void;
-    onEndPreview: () => void;
-};
-export declare function createVisualization(state: RootState, props: Props): import('d3-selection').Selection<SVGSVGElement, undefined, null, undefined>;
-export {};
+import { ValuesType } from '../../internal-types';
+export declare const Group: {
+    readonly table: "table";
+    readonly column: "column";
+};
+export type Group = ValuesType<typeof Group>;
+/**
+ * One dot of the graph. d3 owns the position fields from the first step on,
+ * and a pinned node is one whose fixed pair is set, which is how a drag holds
+ * it against the forces the way the svg drag did.
+ */
+export type VisualizationNode = {
+    id: string;
+    group: Group;
+    name: string;
+    /** The table a column hangs off; a table node has none. */
+    tableId: string | null;
+    x: number;
+    y: number;
+    fx: number | null;
+    fy: number | null;
+};
+export declare const LinkKind: {
+    readonly column: "column";
+    readonly relationship: "relationship";
+};
+export type LinkKind = ValuesType<typeof LinkKind>;
+/**
+ * One line of the graph. Each end is an id when the link is built and the node
+ * it named once the link force has resolved it, which createVisualization does
+ * before it returns; linkEnds is the read that takes that for granted.
+ */
+export type VisualizationLink = {
+    id: string;
+    kind: LinkKind;
+    source: VisualizationNode | string;
+    target: VisualizationNode | string;
+};
+export type VisualizationGraph = {
+    nodes: VisualizationNode[];
+    links: VisualizationLink[];
+};
+export type Visualization = VisualizationGraph & {
+    simulation: Simulation<VisualizationNode, VisualizationLink>;
+};
+/**
+ * The document as a graph: a node per table and per column, a link from each
+ * column to its table and one per pair of tables a relationship joins. The
+ * pair is ordered, so the same two tables joined both ways draw two lines.
+ */
+export declare function convertVisualization({ doc: { tableIds, relationshipIds }, collections, }: RootState): VisualizationGraph;
+/**
+ * Both ends of a link as nodes. The link force rewrote each id to its node when
+ * createVisualization installed it, and no link reaches a scene before that.
+ */
+export declare function linkEnds(link: VisualizationLink): [VisualizationNode, VisualizationNode];
+/**
+ * The graph with the force layout running over it. The forces are the ones the
+ * svg graph ran, links holding their length, nodes repelling and both axes
+ * pulling toward the origin, which the view puts at the middle of the stage.
+ *
+ * @example
+ * const { nodes, links, simulation } = createVisualization(store.state);
+ * simulation.on('tick', redraw);
+ */
+export declare function createVisualization(state: RootState): Visualization;

package/dist/components/visualization/graph-node/GraphNode.d.ts

@@ -0,0 +1,23 @@
+import { FC } from '@dineug/r-html';
+import { Visualization, VisualizationNode } from '../createVisualization';
+import { VisualizationState } from '../visualizationView';
+export type GraphNodeProps = {
+    node: VisualizationNode;
+    /**
+     * The node's place, handed down rather than read off the node, so a step of
+     * the simulation the scene saw reaches this dot as a changed prop.
+     */
+    x: number;
+    y: number;
+    /** Outside the neighbourhood of the hovered table, which the scene decides. */
+    dimmed: boolean;
+    graph: Visualization;
+    state: VisualizationState;
+};
+/**
+ * One dot, owning its own hover and drag. A hovered table opens its preview
+ * and lights its neighbourhood, a hovered column only wears a ring, and a
+ * press pins the node under the pointer and reheats the layout around it.
+ */
+declare const GraphNode: FC<GraphNodeProps>;
+export default GraphNode;

package/dist/components/visualization/table/Table.d.ts

@@ -2,7 +2,6 @@ import { FC } from '@dineug/r-html';
 import { Table } from '../../../internal-types';
 export type TableProps = {
     table: Table;
-    columnId: string | null;
     x: number;
     y: number;
 };

package/dist/components/visualization/table/column/Column.d.ts

@@ -2,7 +2,6 @@ import { FC } from '@dineug/r-html';
 import { Column } from '../../../../internal-types';
 export type ColumnProps = {
     column: Column;
-    selected: boolean;
     widthName: number;
     widthDataType: number;
     widthDefault: number;

package/dist/components/visualization/visualizationView.d.ts

@@ -0,0 +1,90 @@
+import { Point } from '../../internal-types';
+import { Group, VisualizationLink, VisualizationNode } from './createVisualization';
+/** The most of a table name a label shows before it is cut. */
+export declare const NAME_MAX_LENGTH = 15;
+/**
+ * A name as its label shows it. The cut counts code points rather than UTF-16
+ * units, so a name ending in an emoji or a CJK glyph is never split inside one.
+ *
+ * @example
+ * truncateName('a_very_long_table_name'); // 'a_very_long_tab…'
+ */
+export declare function truncateName(name: string): string;
+/** The text a table's label draws: its name cut to length, or a placeholder. */
+export declare function labelOf(node: Pick<VisualizationNode, 'name'>): string;
+/** Whether a table has a name of its own, which is what its label is painted by. */
+export declare const hasName: (node: Pick<VisualizationNode, "name">) => boolean;
+export declare const TABLE_RADIUS = 8;
+export declare const COLUMN_RADIUS = 4;
+/** A table draws larger than the columns that hang off it. */
+export declare const nodeRadius: (group: Group) => number;
+/**
+ * What a dot, a line or a name fades to while it sits outside the lit
+ * neighbourhood of a hovered table, so that neighbourhood reads on its own.
+ */
+export declare const DIM_OPACITY = 0.2;
+/** The ids a hovered table lights up: nodes on one side, links on the other. */
+export type Highlight = {
+    nodeIds: Set<string>;
+    linkIds: Set<string>;
+};
+/**
+ * What a hovered table lights: itself, every link at it and whatever sits at
+ * the other end of each, which is its own columns and the tables its
+ * relationships join either way round. The rest is what the scene fades.
+ *
+ * @example
+ * const { nodeIds, linkIds } = highlightOf(graph.links, 't1');
+ */
+export declare function highlightOf(links: VisualizationLink[], tableId: string): Highlight;
+/**
+ * The scale a table name is fully gone below and the one it is whole from,
+ * fading between the two: the graph reads as shapes from afar and as names at
+ * rest, as Obsidian's graph does. A column carries no name at any scale.
+ */
+export declare const LABEL_FADE_START = 0.5;
+export declare const LABEL_FADE_END = 1;
+export declare function labelOpacity(scale: number): number;
+export declare const ZOOM_MIN = 0.1;
+export declare const ZOOM_MAX = 4;
+/** Where the scene's origin sits on the stage, and how large a scene unit is. */
+export type VisualizationView = {
+    x: number;
+    y: number;
+    scale: number;
+};
+/** The origin at the middle of the stage, where the forces gather the graph. */
+export declare function createView(width: number, height: number): VisualizationView;
+/**
+ * The view after a zoom about a stage point. The scene point under that point
+ * is held still, so whatever the pointer is over grows or shrinks around it.
+ *
+ * @example
+ * const next = zoomAt(view, { x: event.offsetX, y: event.offsetY }, 1.2);
+ */
+export declare function zoomAt(view: VisualizationView, point: Point, factor: number): VisualizationView;
+/**
+ * How much a wheel event scales the view, above one for a wheel rolled away
+ * from the user. Exponential in the travel, so a notch each way cancels out.
+ */
+export declare function wheelZoomFactor(deltaY: number, deltaMode?: number): number;
+/**
+ * Everything the panel keeps between renders, and none of it in the store: the
+ * view is this client's alone and a force layout is not part of the document.
+ */
+export type VisualizationState = VisualizationView & {
+    /** Bumped by every simulation step, which is what redraws the moved graph. */
+    tick: number;
+    /** A node or the view is being dragged, which is when no preview opens. */
+    drag: boolean;
+    /** The dot under the pointer, table or column, the one that wears the ring. */
+    hoveredId: string | null;
+    /**
+     * The hovered dot when it is a table, and null over a column: the preview
+     * opens for it, and the graph fades around its neighbourhood.
+     */
+    hoveredTableId: string | null;
+    previewX: number;
+    previewY: number;
+};
+export declare function createVisualizationState(width: number, height: number): VisualizationState;

package/dist/constants/language.d.ts

@@ -1 +1,7 @@
-export declare const LanguageToLangMap: Record<number, string>;
+/**
+ * Shiki grammar names. Spelled out rather than left as string, which is what
+ * the annotation used to widen them to — CodeBlock's lang is a union, and
+ * widening here meant nothing checked that these were members of it.
+ */
+export type Lang = 'csharp' | 'go' | 'graphql' | 'java' | 'kotlin' | 'python' | 'scala' | 'sql' | 'typescript';
+export declare const LanguageToLangMap: Record<number, Lang>;

package/dist/constants/layout.d.ts

@@ -1,6 +1,7 @@
 export declare const START_X = 200;
 export declare const START_Y = 100;
 export declare const START_ADD = 50;
+export declare const DUPLICATE_MIN_MOVE = 4;
 export declare const DEFAULT_WIDTH = 1200;
 export declare const DEFAULT_HEIGHT: number;
 export declare const INPUT_HEIGHT = 20;
@@ -31,3 +32,15 @@ export declare const MINIMAP_SIZE = 150;
 export declare const MINIMAP_MARGIN = 20;
 export declare const TOOLBAR_HEIGHT = 30;
 export declare const DIFF_TREE_WIDTH = 200;
+/**
+ * How thick a relationship connector is drawn. A whole number rather than a
+ * fraction, so the stroke lands on pixel boundaries instead of spreading across
+ * two rows at partial alpha on a 1x display.
+ */
+export declare const RELATIONSHIP_STROKE_WIDTH = 2;
+/**
+ * The invisible band that catches the pointer for a connector, because
+ * hit-testing follows the painted stroke. Narrower than NUDGE_GAP, so it stays
+ * clear of the neighbouring corridor at the router's usual separation.
+ */
+export declare const RELATIONSHIP_HIT_STROKE_WIDTH = 8;

package/dist/constants/schema.d.ts

@@ -34,6 +34,8 @@ export declare const Database: {
     readonly Oracle: 8;
     readonly PostgreSQL: 16;
     readonly SQLite: 32;
+    readonly Databricks: 64;
+    readonly Snowflake: 128;
 };
 export declare const DatabaseList: readonly number[];
 export declare const Language: {
@@ -44,6 +46,13 @@ export declare const Language: {
     readonly TypeScript: 16;
     readonly JPA: 32;
     readonly Scala: 64;
+    readonly Go: 128;
+    readonly SQLAlchemy: 256;
+    readonly TypeORM: 512;
+    readonly Sequelize: 1024;
+    readonly Drizzle: 2048;
+    readonly DBML: 4096;
+    readonly AML: 8192;
 };
 export declare const LanguageList: readonly number[];
 export declare const NameCase: {
@@ -95,12 +104,12 @@ export declare const OrderType: {
 };
 export declare const OrderTypeList: readonly number[];
 export declare const SaveSettingType: {
-    scroll: number;
-    zoomLevel: number;
+    readonly scroll: 1;
+    readonly zoomLevel: 2;
 };
 export declare const CANVAS_SIZE_MAX: 20000;
 export declare const CANVAS_SIZE_MIN: 2000;
-export declare const CANVAS_ZOOM_MAX: 1;
+export declare const CANVAS_ZOOM_MAX: 1.5;
 export declare const CANVAS_ZOOM_MIN: 0.1;
 export declare const BracketTypeMap: Record<number, string>;
 export declare const ColumnTypeToName: Record<number, string>;

package/dist/constants/sql/dataType/Databricks.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeHint } from '.';
+/**
+ * https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-datatypes
+ */
+export declare const DatabricksTypes: DataTypeHint[];

package/dist/constants/sql/dataType/MSSQL.d.ts

@@ -1,5 +1,5 @@
 import { DataTypeHint } from '.';
 /**
- * https://docs.microsoft.com/ko-kr/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver15
+ * https://learn.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql
  */
 export declare const MSSQLTypes: DataTypeHint[];

package/dist/constants/sql/dataType/MySQL.d.ts

@@ -1,5 +1,5 @@
 import { DataTypeHint } from '.';
 /**
- * https://dev.mysql.com/doc/refman/8.0/en/data-types.html
+ * https://dev.mysql.com/doc/refman/8.4/en/data-types.html
  */
 export declare const MySQLTypes: DataTypeHint[];

package/dist/constants/sql/dataType/Oracle.d.ts

@@ -1,5 +1,5 @@
 import { DataTypeHint } from '.';
 /**
- * https://docs.oracle.com/cd/B28359_01/server.111/b28318/datatype.htm#CNCPT012
+ * https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/Data-Types.html
  */
 export declare const OracleTypes: DataTypeHint[];

package/dist/constants/sql/dataType/Snowflake.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeHint } from '.';
+/**
+ * https://docs.snowflake.com/en/sql-reference-data-types
+ */
+export declare const SnowflakeTypes: DataTypeHint[];

package/dist/constants/sql/database.d.ts

@@ -1,10 +1,12 @@
 import { ValuesType } from '../../internal-types';
 export declare const DatabaseVendor: {
+    readonly Databricks: "Databricks";
     readonly MariaDB: "MariaDB";
     readonly MSSQL: "MSSQL";
     readonly MySQL: "MySQL";
     readonly Oracle: "Oracle";
     readonly PostgreSQL: "PostgreSQL";
+    readonly Snowflake: "Snowflake";
     readonly SQLite: "SQLite";
 };
 export type DatabaseVendor = ValuesType<typeof DatabaseVendor>;

package/dist/engine/history.d.ts

@@ -1,8 +1,9 @@
 import { AnyAction } from '@dineug/r-html';
 type Dispatch = (actions: AnyAction[]) => void;
+type GetNextVersion = () => number;
 export type Command = {
-    undo: (dispatch: Dispatch) => void;
-    redo: (dispatch: Dispatch) => void;
+    undo: (dispatch: Dispatch, getNextVersion: GetNextVersion) => void;
+    redo: (dispatch: Dispatch, getNextVersion: GetNextVersion) => void;
 };
 export type CommandKey = keyof Command;
 export type History = {
@@ -24,11 +25,12 @@ type HasHistory = {
 export type HistoryOptions = {
     notify: (has: HasHistory) => void;
     dispatch: Dispatch;
+    getNextVersion: GetNextVersion;
 };
 type HistoryState = {
     commands: Command[];
     cursor: number;
     limit: number;
 };
-export declare function createHistory({ notify, dispatch }: HistoryOptions, initialState?: HistoryState): History;
+export declare function createHistory({ notify, dispatch, getNextVersion }: HistoryOptions, initialState?: HistoryState): History;
 export {};

package/dist/engine/hooks.d.ts

@@ -1,8 +1,8 @@
-import { Channel, CoroutineCreator } from '@dineug/go';
 import { AnyAction, createAction } from '@dineug/r-html';
+import { Observable, Subscription } from 'rxjs';
 import { EngineContext } from './context';
 import { RootState } from './state';
 type ActionCreator = ReturnType<typeof createAction<any>>;
-export type CO = (channel: Channel<AnyAction>, getState: () => RootState, ctx: EngineContext) => ReturnType<CoroutineCreator>;
-export type Hook = [Array<ActionCreator | string>, CO];
+export type HookEffect = (action$: Observable<AnyAction>, getState: () => RootState, ctx: EngineContext) => Subscription;
+export type Hook = [Array<ActionCreator | string>, HookEffect];
 export {};

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

@@ -2,7 +2,8 @@ import { Reducer } from '@dineug/r-html';
 import { EngineContext } from '../../context';
 import { RootState } from '../../state';
 import { LWW, ValuesType } from '../../../internal-types';
-import { FocusType, MoveKey, SelectType } from './state';
+import { Rect } from '../../../utils/dragSelect';
+import { FocusType, MoveKey, SelectType, SharedFocus } from './state';
 export declare const ActionType: {
     readonly changeHasHistory: "editor.changeHasHistory";
     readonly selectAll: "editor.selectAll";
@@ -19,6 +20,9 @@ export declare const ActionType: {
     readonly focusMoveTable: "editor.focusMoveTable";
     readonly editTable: "editor.editTable";
     readonly editTableEnd: "editor.editTableEnd";
+    readonly editMemo: "editor.editMemo";
+    readonly editMemoEnd: "editor.editMemoEnd";
+    readonly scrollMemo: "editor.scrollMemo";
     readonly selectAllColumn: "editor.selectAllColumn";
     readonly drawStartRelationship: "editor.drawStartRelationship";
     readonly drawStartAddRelationship: "editor.drawStartAddRelationship";
@@ -30,6 +34,10 @@ export declare const ActionType: {
     readonly dragstartColumn: "editor.dragstartColumn";
     readonly dragendColumn: "editor.dragendColumn";
     readonly sharedMouseTracker: "editor.sharedMouseTracker";
+    readonly sharedFocusTracker: "editor.sharedFocusTracker";
+    readonly sharedSelectionTracker: "editor.sharedSelectionTracker";
+    readonly sharedDragSelectTracker: "editor.sharedDragSelectTracker";
+    readonly dragSelectRect: "editor.dragSelectRect";
     readonly validationIds: "editor.validationIds";
     readonly getLWW: "editor.getLWW";
     readonly mergeLWW: "editor.mergeLWW";
@@ -73,6 +81,15 @@ export type ActionMap = {
     };
     [ActionType.editTable]: void;
     [ActionType.editTableEnd]: void;
+    [ActionType.editMemo]: {
+        id: string;
+    };
+    [ActionType.editMemoEnd]: void;
+    [ActionType.scrollMemo]: {
+        id: string;
+        /** How far down its body the memo is shown from, in body px. */
+        scrollTop: number;
+    };
     [ActionType.selectAllColumn]: void;
     [ActionType.drawStartRelationship]: {
         relationshipType: number;
@@ -101,6 +118,18 @@ export type ActionMap = {
         x: number;
         y: number;
     };
+    [ActionType.sharedFocusTracker]: {
+        focus: SharedFocus | null;
+    };
+    [ActionType.sharedSelectionTracker]: {
+        selectedIds: string[];
+    };
+    [ActionType.sharedDragSelectTracker]: {
+        rect: Rect | null;
+    };
+    [ActionType.dragSelectRect]: {
+        rect: Rect | null;
+    };
     [ActionType.validationIds]: void;
     [ActionType.getLWW]: void;
     [ActionType.mergeLWW]: {

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

@@ -1,5 +1,7 @@
 import { ReducerType } from './actions';
 import { FocusType, MoveKey, SelectType } from './state';
+export declare const SHARED_FOCUS_TRACKER_TIMEOUT: number;
+export declare const SHARED_DRAG_SELECT_TRACKER_TIMEOUT: number;
 export declare const changeHasHistoryAction: {
     (payload: {
         hasUndo: boolean;
@@ -119,6 +121,31 @@ export declare const editTableEndAction: {
     toString(): string;
     type: string;
 };
+export declare const editMemoAction: {
+    (payload: {
+        id: string;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const editMemoEndAction: {
+    (payload: void): import('@dineug/r-html').AnyAction<void>;
+    toString(): string;
+    type: string;
+};
+export declare const scrollMemoAction: {
+    (payload: {
+        id: string;
+        scrollTop: number;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        scrollTop: number;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const selectAllColumnAction: {
     (payload: void): import('@dineug/r-html').AnyAction<void>;
     toString(): string;
@@ -208,6 +235,42 @@ export declare const sharedMouseTrackerAction: {
     toString(): string;
     type: string;
 };
+export declare const sharedFocusTrackerAction: {
+    (payload: {
+        focus: import('./state').SharedFocus | null;
+    }): import('@dineug/r-html').AnyAction<{
+        focus: import('./state').SharedFocus | null;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const sharedSelectionTrackerAction: {
+    (payload: {
+        selectedIds: string[];
+    }): import('@dineug/r-html').AnyAction<{
+        selectedIds: string[];
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const sharedDragSelectTrackerAction: {
+    (payload: {
+        rect: import('../../../utils/dragSelect').Rect | null;
+    }): import('@dineug/r-html').AnyAction<{
+        rect: import('../../../utils/dragSelect').Rect | null;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const dragSelectRectAction: {
+    (payload: {
+        rect: import('../../../utils/dragSelect').Rect | null;
+    }): import('@dineug/r-html').AnyAction<{
+        rect: import('../../../utils/dragSelect').Rect | null;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const validationIdsAction: {
     (payload: void): import('@dineug/r-html').AnyAction<void>;
     toString(): string;
@@ -243,6 +306,9 @@ export declare const editorReducers: {
     "editor.focusMoveTable": ReducerType<"editor.focusMoveTable">;
     "editor.editTable": ReducerType<"editor.editTable">;
     "editor.editTableEnd": ReducerType<"editor.editTableEnd">;
+    "editor.editMemo": ReducerType<"editor.editMemo">;
+    "editor.editMemoEnd": ReducerType<"editor.editMemoEnd">;
+    "editor.scrollMemo": ReducerType<"editor.scrollMemo">;
     "editor.selectAllColumn": ReducerType<"editor.selectAllColumn">;
     "editor.drawStartRelationship": ReducerType<"editor.drawStartRelationship">;
     "editor.drawStartAddRelationship": ReducerType<"editor.drawStartAddRelationship">;
@@ -254,6 +320,10 @@ export declare const editorReducers: {
     "editor.dragstartColumn": ReducerType<"editor.dragstartColumn">;
     "editor.dragendColumn": ReducerType<"editor.dragendColumn">;
     "editor.sharedMouseTracker": ReducerType<"editor.sharedMouseTracker">;
+    "editor.sharedFocusTracker": ReducerType<"editor.sharedFocusTracker">;
+    "editor.sharedSelectionTracker": ReducerType<"editor.sharedSelectionTracker">;
+    "editor.sharedDragSelectTracker": ReducerType<"editor.sharedDragSelectTracker">;
+    "editor.dragSelectRect": ReducerType<"editor.dragSelectRect">;
     "editor.validationIds": ReducerType<"editor.validationIds">;
     "editor.getLWW": ReducerType<"editor.getLWW">;
     "editor.mergeLWW": ReducerType<"editor.mergeLWW">;
@@ -378,6 +448,31 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    editMemoAction: {
+        (payload: {
+            id: string;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    editMemoEndAction: {
+        (payload: void): import('@dineug/r-html').AnyAction<void>;
+        toString(): string;
+        type: string;
+    };
+    scrollMemoAction: {
+        (payload: {
+            id: string;
+            scrollTop: number;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            scrollTop: number;
+        }>;
+        toString(): string;
+        type: string;
+    };
     selectAllColumnAction: {
         (payload: void): import('@dineug/r-html').AnyAction<void>;
         toString(): string;
@@ -467,6 +562,42 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    sharedFocusTrackerAction: {
+        (payload: {
+            focus: import('./state').SharedFocus | null;
+        }): import('@dineug/r-html').AnyAction<{
+            focus: import('./state').SharedFocus | null;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    sharedSelectionTrackerAction: {
+        (payload: {
+            selectedIds: string[];
+        }): import('@dineug/r-html').AnyAction<{
+            selectedIds: string[];
+        }>;
+        toString(): string;
+        type: string;
+    };
+    sharedDragSelectTrackerAction: {
+        (payload: {
+            rect: import('../../../utils/dragSelect').Rect | null;
+        }): import('@dineug/r-html').AnyAction<{
+            rect: import('../../../utils/dragSelect').Rect | null;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    dragSelectRectAction: {
+        (payload: {
+            rect: import('../../../utils/dragSelect').Rect | null;
+        }): import('@dineug/r-html').AnyAction<{
+            rect: import('../../../utils/dragSelect').Rect | null;
+        }>;
+        toString(): string;
+        type: string;
+    };
     validationIdsAction: {
         (payload: void): import('@dineug/r-html').AnyAction<void>;
         toString(): string;

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

@@ -1,10 +1,20 @@
 import { GeneratorAction } from '../../generator.actions';
+import { Point } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
+import { ClipboardPayload } from '../../../utils/table-clipboard';
 import { MoveKey } from './state';
 export declare const loadJsonAction$: (value: string) => GeneratorAction;
 export declare const initialLoadJsonAction$: (value: string) => GeneratorAction;
 export declare const moveAllAction$: (movementX: number, movementY: number) => GeneratorAction;
 export declare const removeSelectedAction$: () => GeneratorAction;
+export type DuplicateConfig = {
+    tableIds?: string[];
+    memoIds?: string[];
+    offset: Point;
+    escapeCollision: boolean;
+};
+export declare const pasteEntitiesAction$: (payload: ClipboardPayload, pasteRound: number) => GeneratorAction;
+export declare const duplicateAction$: ({ tableIds, memoIds, offset, escapeCollision, }: DuplicateConfig) => GeneratorAction;
 export declare const dragSelectAction$: (dragRect: Rect) => GeneratorAction;
 export declare const unselectAllAction$: () => GeneratorAction;
 export declare const focusMoveTableAction$: (moveKey: MoveKey, shiftKey: boolean) => GeneratorAction;
@@ -12,6 +22,9 @@ export declare const drawStartRelationshipAction$: (relationshipType: number) =>
 export declare const drawStartAddRelationshipAction$: (tableId: string) => GeneratorAction;
 export declare const changeColorAllAction$: (color: string) => GeneratorAction;
 export declare const loadSchemaSQLAction$: (value: string) => GeneratorAction;
+export declare const loadSchemaGraphQLAction$: (value: string) => GeneratorAction;
+export declare const loadSchemaDBMLAction$: (value: string) => GeneratorAction;
+export declare const loadSchemaAMLAction$: (value: string) => GeneratorAction;
 export declare const dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
 export declare const dragoverColumnAction$: (targetId: string, targetTableId: string) => GeneratorAction;
 export declare const columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;
@@ -21,6 +34,8 @@ export declare const actions$: {
     initialLoadJsonAction$: (value: string) => GeneratorAction;
     moveAllAction$: (movementX: number, movementY: number) => GeneratorAction;
     removeSelectedAction$: () => GeneratorAction;
+    pasteEntitiesAction$: (payload: ClipboardPayload, pasteRound: number) => GeneratorAction;
+    duplicateAction$: ({ tableIds, memoIds, offset, escapeCollision, }: DuplicateConfig) => GeneratorAction;
     dragSelectAction$: (dragRect: Rect) => GeneratorAction;
     unselectAllAction$: () => GeneratorAction;
     focusMoveTableAction$: (moveKey: MoveKey, shiftKey: boolean) => GeneratorAction;
@@ -28,6 +43,9 @@ export declare const actions$: {
     drawStartAddRelationshipAction$: (tableId: string) => GeneratorAction;
     changeColorAllAction$: (color: string) => GeneratorAction;
     loadSchemaSQLAction$: (value: string) => GeneratorAction;
+    loadSchemaGraphQLAction$: (value: string) => GeneratorAction;
+    loadSchemaDBMLAction$: (value: string) => GeneratorAction;
+    loadSchemaAMLAction$: (value: string) => GeneratorAction;
     dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
     dragoverColumnAction$: (targetId: string, targetTableId: string) => GeneratorAction;
     columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;