@dineug/erd-editor 3.10.0 → 4.0.0

package/dist/engine/index.js

@@ -1,40 +1,45 @@
-import { Ln as e, Va as t, _ as n, dr as r, h as i, n as a, nt as o, r as s, t as c, u as l, un as u, x as d } from "../loadValue-Mdc5K4qO.js";
-import { n as f, r as p } from "../schemaGCService-CZtGFh2z.js";
-import { omit as m } from "es-toolkit";
-import { Observable as h, Subject as g, debounceTime as _, map as v } from "rxjs";
+import { $ as e, Bo as t, Jn as n, c as r, ds as i, mn as a, n as o, ps as s, r as c, t as l, u, v as d, y as f } from "../loadValue-B3EFSe9k.js";
+import { Observable as p, Subject as m, debounceTime as h, map as g } from "rxjs";
+import { omit as _ } from "es-toolkit";
 //#region src/engine/replication-store.ts
-var y = { change: "change" };
-function b(b) {
-	let x = /* @__PURE__ */ new Set(), S = n(b), C = l(S, !1);
-	C.dispatchSync(e({
+var v = t(f), y = { change: "change" };
+function b(t) {
+	let b = /* @__PURE__ */ new Set(), x = u({
+		...t,
+		routes: !1
+	}), { clock: S } = x, C = c(x, !1);
+	C.dispatchSync(n({
 		width: 0,
 		height: 0
 	}));
-	let w = a(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(i(d), _(200)), D = /* @__PURE__ */ new Set(), O = null, k = (e) => (D.has(e) || D.add(e), () => {
+	let w = o(C), T = new m(), E = new p((e) => C.subscribe((t) => e.next(t))).pipe(r(f), h(200)), D = /* @__PURE__ */ new Set(), O = null, k = (e) => (D.has(e) || D.add(e), () => {
 		D.delete(e);
 	}), A = (e, t) => {
 		D.forEach((n) => {
 			let r = Reflect.get(n, e);
-			u(r, t);
+			a(r, t);
 		});
-	}, j = (e) => {
-		O = null, C.dispatchSync(o(c(e)));
-		let n = f(t(C.state));
-		Object.values(n).some((e) => e.length) && (p(C.state, n), C.dispatchSync(r())), s(C.state, S);
+	}, j = (t) => {
+		O = null, C.dispatchSync(e(l(t)));
 	}, M = (e) => {
 		T.next([e].flat());
 	};
-	return x.add(E.subscribe(() => {
-		let e = t(C.state), n = O !== null && e !== O;
+	return b.add(E.subscribe(() => {
+		let e = i(C.state), t = O !== null && e !== O;
 		O !== null && (O = e), A(y.change, {
 			value: e,
-			changed: n
+			changed: t
 		});
-	})).add(T.pipe(i(d), v((e) => e.map((e) => m(e, ["tags"])))).subscribe((e) => {
-		O ??= t(C.state), C.dispatchSync(e);
+	})).add(T.pipe(r(d), g((e) => e.map((e) => _(e, ["tags"])))).subscribe((e) => {
+		e.some(({ type: e }) => v(e)) && (O ??= i(C.state));
+		let t = S.getNextVersion();
+		e.forEach((e) => e.version ??= t), C.dispatchSync(e), e.forEach((e) => S.merge(e.version));
 	})), Object.freeze({
 		get value() {
-			return t(C.state);
+			return i(C.state);
+		},
+		get runtimeValue() {
+			return s(C.state);
 		},
 		on: k,
 		setInitialValue: j,
@@ -43,7 +48,7 @@ function b(b) {
 		},
 		dispatchSync: M,
 		destroy: () => {
-			Array.from(x).forEach((e) => e.unsubscribe()), x.clear(), D.clear(), C.destroy(), w.destroy();
+			Array.from(b).forEach((e) => e.unsubscribe()), b.clear(), D.clear(), C.destroy(), w.destroy();
 		}
 	});
 }

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

@@ -22,6 +22,8 @@ export declare const ActionType: {
     readonly editTableEnd: "editor.editTableEnd";
     readonly editMemo: "editor.editMemo";
     readonly editMemoEnd: "editor.editMemoEnd";
+    readonly editTableGroup: "editor.editTableGroup";
+    readonly editTableGroupEnd: "editor.editTableGroupEnd";
     readonly scrollMemo: "editor.scrollMemo";
     readonly selectAllColumn: "editor.selectAllColumn";
     readonly drawStartRelationship: "editor.drawStartRelationship";
@@ -32,6 +34,7 @@ export declare const ActionType: {
     readonly hoverRelationshipMap: "editor.hoverRelationshipMap";
     readonly changeOpenMap: "editor.changeOpenMap";
     readonly changeHandTool: "editor.changeHandTool";
+    readonly changeDrawTableGroup: "editor.changeDrawTableGroup";
     readonly changeZenMode: "editor.changeZenMode";
     readonly dragstartColumn: "editor.dragstartColumn";
     readonly dragendColumn: "editor.dragendColumn";
@@ -40,7 +43,6 @@ export declare const ActionType: {
     readonly sharedSelectionTracker: "editor.sharedSelectionTracker";
     readonly sharedDragSelectTracker: "editor.sharedDragSelectTracker";
     readonly dragSelectRect: "editor.dragSelectRect";
-    readonly validationIds: "editor.validationIds";
     readonly getLWW: "editor.getLWW";
     readonly mergeLWW: "editor.mergeLWW";
     readonly viewOpen: "editor.viewOpen";
@@ -98,6 +100,10 @@ export type ActionMap = {
         id: string;
     };
     [ActionType.editMemoEnd]: void;
+    [ActionType.editTableGroup]: {
+        id: string;
+    };
+    [ActionType.editTableGroupEnd]: void;
     [ActionType.scrollMemo]: {
         id: string;
         /** How far down its body the memo is shown from, in body px. */
@@ -125,6 +131,9 @@ export type ActionMap = {
     [ActionType.changeHandTool]: {
         value: boolean;
     };
+    [ActionType.changeDrawTableGroup]: {
+        value: boolean;
+    };
     [ActionType.changeZenMode]: {
         value: boolean;
     };
@@ -149,7 +158,6 @@ export type ActionMap = {
     [ActionType.dragSelectRect]: {
         rect: Rect | null;
     };
-    [ActionType.validationIds]: void;
     [ActionType.getLWW]: void;
     [ActionType.mergeLWW]: {
         lww: LWW;

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

@@ -135,6 +135,20 @@ export declare const editMemoEndAction: {
     toString(): string;
     type: string;
 };
+export declare const editTableGroupAction: {
+    (payload: {
+        id: string;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const editTableGroupEndAction: {
+    (payload: void): import('@dineug/r-html').AnyAction<void>;
+    toString(): string;
+    type: string;
+};
 export declare const scrollMemoAction: {
     (payload: {
         id: string;
@@ -217,6 +231,15 @@ export declare const changeHandToolAction: {
     toString(): string;
     type: string;
 };
+export declare const changeDrawTableGroupAction: {
+    (payload: {
+        value: boolean;
+    }): import('@dineug/r-html').AnyAction<{
+        value: boolean;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const changeZenModeAction: {
     (payload: {
         value: boolean;
@@ -289,11 +312,6 @@ export declare const dragSelectRectAction: {
     toString(): string;
     type: string;
 };
-export declare const validationIdsAction: {
-    (payload: void): import('@dineug/r-html').AnyAction<void>;
-    toString(): string;
-    type: string;
-};
 export declare const getLWWAction: {
     (payload: void): import('@dineug/r-html').AnyAction<void>;
     toString(): string;
@@ -337,6 +355,8 @@ export declare const editorReducers: {
     "editor.editTableEnd": ReducerType<"editor.editTableEnd">;
     "editor.editMemo": ReducerType<"editor.editMemo">;
     "editor.editMemoEnd": ReducerType<"editor.editMemoEnd">;
+    "editor.editTableGroup": ReducerType<"editor.editTableGroup">;
+    "editor.editTableGroupEnd": ReducerType<"editor.editTableGroupEnd">;
     "editor.scrollMemo": ReducerType<"editor.scrollMemo">;
     "editor.selectAllColumn": ReducerType<"editor.selectAllColumn">;
     "editor.drawStartRelationship": ReducerType<"editor.drawStartRelationship">;
@@ -347,6 +367,7 @@ export declare const editorReducers: {
     "editor.hoverRelationshipMap": ReducerType<"editor.hoverRelationshipMap">;
     "editor.changeOpenMap": ReducerType<"editor.changeOpenMap">;
     "editor.changeHandTool": ReducerType<"editor.changeHandTool">;
+    "editor.changeDrawTableGroup": ReducerType<"editor.changeDrawTableGroup">;
     "editor.changeZenMode": ReducerType<"editor.changeZenMode">;
     "editor.dragstartColumn": ReducerType<"editor.dragstartColumn">;
     "editor.dragendColumn": ReducerType<"editor.dragendColumn">;
@@ -355,7 +376,6 @@ export declare const editorReducers: {
     "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">;
 };
@@ -618,6 +638,20 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    editTableGroupAction: {
+        (payload: {
+            id: string;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    editTableGroupEndAction: {
+        (payload: void): import('@dineug/r-html').AnyAction<void>;
+        toString(): string;
+        type: string;
+    };
     scrollMemoAction: {
         (payload: {
             id: string;
@@ -700,6 +734,15 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    changeDrawTableGroupAction: {
+        (payload: {
+            value: boolean;
+        }): import('@dineug/r-html').AnyAction<{
+            value: boolean;
+        }>;
+        toString(): string;
+        type: string;
+    };
     changeZenModeAction: {
         (payload: {
             value: boolean;
@@ -772,11 +815,6 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
-    validationIdsAction: {
-        (payload: void): import('@dineug/r-html').AnyAction<void>;
-        toString(): string;
-        type: string;
-    };
     getLWWAction: {
         (payload: void): import('@dineug/r-html').AnyAction<void>;
         toString(): string;

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

@@ -1,17 +1,32 @@
+import { ERDEditorSchemaV3 } from '@dineug/erd-editor-schema';
+import { EngineContext } from '../../context';
 import { GeneratorAction } from '../../generator.actions';
+import { RootState } from '../../state';
 import { Point } from '../../../internal-types';
-import { Rect } from '../../../utils/dragSelect';
+import { TableMove } from '../../../konva/scene/contentBounds';
+import { Rect } from '../../../konva/scene/metrics';
+import { Rect as DragRect } from '../../../utils/dragSelect';
 import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
 import { ClipboardPayload } from '../../../utils/table-clipboard';
 import { MoveKey } from './state';
+import { CreateEntityActions } from './utils/duplicate';
 export declare const loadJsonAction$: (value: string) => GeneratorAction;
 export declare const initialLoadJsonAction$: (value: string) => GeneratorAction;
 /**
- * Moves the selection by a pointer step, scaled by the zoom of the scene the
- * drag runs in. From a view scene the step goes to that view's own placement,
- * which holds tables alone, and the document's placement is left where it is.
+ * One drag of the selection: the document groups and tables it carries, read at its first step and
+ * kept to its last, since steps summed per list would split if a peer changed a group's members, or
+ * hid the groups and so took them out of the selection, midway.
  */
-export declare const moveAllAction$: (movementX: number, movementY: number, source?: GeometrySource) => GeneratorAction;
+export type MoveAllGesture = {
+    tableGroupIds?: string[];
+    tableIds?: string[];
+};
+/**
+ * Moves the selection by a pointer step the scene's zoom scales, a selected
+ * group carrying its members, each table once. From a view scene the step goes
+ * to that view's own placement, which holds tables alone, the document's kept.
+ */
+export declare const moveAllAction$: (movementX: number, movementY: number, source?: GeometrySource, gesture?: MoveAllGesture) => GeneratorAction;
 export declare const removeSelectedAction$: () => GeneratorAction;
 export type DuplicateConfig = {
     tableIds?: string[];
@@ -21,17 +36,98 @@ export type DuplicateConfig = {
 };
 export declare const pasteEntitiesAction$: (payload: ClipboardPayload, pasteRound: number) => GeneratorAction;
 export declare const duplicateAction$: ({ tableIds, memoIds, offset, escapeCollision, }: DuplicateConfig) => GeneratorAction;
+/**
+ * Where the tables of a document an append brings take their points from,
+ * before the block they make goes under the diagram: as the file has them, as
+ * the grid an import lands in has them, or as a placement answered them.
+ */
+export type AppendLayout = 'file' | 'grid' | ReadonlyArray<TableMove>;
+/** What an append adds: its actions, the new ids, and the box they make where they land. */
+export type SchemaAppend = CreateEntityActions & {
+    rect: Rect;
+};
+/**
+ * An import's document with each table at its point in the grid and each group
+ * with members round them, written into the text it loads: every peer takes the
+ * points the sender laid out, where a sort replayed would measure with its own fonts.
+ *
+ * @example
+ * store.dispatchSync(loadJsonAction$(withGridPoints(json, store.state, ctx)));
+ */
+export declare function withGridPoints(json: string, state: RootState, ctx: EngineContext): string;
+/**
+ * A document's tables, relationships, indexes and memos as new entities of this
+ * one, made as a paste makes them with no field at its default sent, their block
+ * a gap under the diagram. Null for unreadable text or a document holding nothing.
+ *
+ * @example
+ * const append = toSchemaAppend(state, json, 'grid', ctx);
+ */
+export declare function toSchemaAppend(state: RootState, json: string, layout: AppendLayout, ctx: EngineContext): SchemaAppend | null;
+/**
+ * Adds a document read from a file below the diagram as new entities in one undo
+ * step, leaving the tables already there and every setting as they are; unreadable
+ * text, or a document holding nothing, adds nothing.
+ *
+ * @example
+ * store.dispatch(appendSchemaJsonAction$(json, 'file'));
+ */
+export declare const appendSchemaJsonAction$: (json: string, layout?: AppendLayout) => GeneratorAction;
+/**
+ * Adds a schema read from SQL, GraphQL, DBML or AML to this document, its
+ * tables laid out in the grid below the diagram, as appendSchemaJsonAction$
+ * adds a document.
+ *
+ * @example
+ * store.dispatch(appendSchemaAction$('sql', value));
+ */
+export declare const appendSchemaAction$: (type: SchemaImportType, value: string) => GeneratorAction;
 /**
  * Selects what the rect covers among what the source shows, each entity read
  * at the point and the size that source draws it: a view places its tables
  * and shows no memo, so a marquee drawn over it picks by the view, not the document.
  */
-export declare const dragSelectAction$: (dragRect: Rect, source?: GeometrySource) => GeneratorAction;
+export declare const dragSelectAction$: (dragRect: DragRect, source?: GeometrySource) => GeneratorAction;
 export declare const unselectAllAction$: () => GeneratorAction;
 export declare const focusMoveTableAction$: (moveKey: MoveKey, shiftKey: boolean) => GeneratorAction;
 export declare const drawStartRelationshipAction$: (relationshipType: number) => GeneratorAction;
 export declare const drawStartAddRelationshipAction$: (tableId: string) => GeneratorAction;
+/**
+ * Paints every selected table, memo and group the color, sending nothing for
+ * one that already is, in any letter case, so a color pressed again adds no
+ * undo entry while one an undo took back is painted again; one stream group.
+ */
 export declare const changeColorAllAction$: (color: string) => GeneratorAction;
+/**
+ * Clears the color of every selected table, memo and group that has one: one
+ * stream group, so one undo entry, and none for a selection that has no color.
+ */
+export declare const removeColorAllAction$: () => GeneratorAction;
+/** The four text formats an import parses into a document of its own. */
+export type SchemaImportType = 'sql' | 'graphql' | 'dbml' | 'aml';
+/**
+ * Writes the settings of the document an import replaces over the parser's,
+ * all but the view, locks included, the view locked where the parser left it.
+ * A placed import writes them again as it lands.
+ *
+ * @example
+ * withImportSettings(schema, store.state.settings);
+ */
+export declare function withImportSettings(schema: Pick<ERDEditorSchemaV3, 'settings'>, settings: RootState['settings']): void;
+/**
+ * The document an import parses to, carrying the settings of the one it
+ * replaces. Its tables still stand where the parser left them: the grid or a
+ * placement decides where they go.
+ *
+ * @example
+ * const json = toSchemaImportJson('sql', value, store.state, ctx);
+ */
+export declare function toSchemaImportJson(type: SchemaImportType, value: string, { settings }: RootState, ctx: EngineContext): string;
+/**
+ * The load each of the four text imports runs: the parsed document replaces
+ * this one, its tables at the points the grid gives them here.
+ */
+export declare const loadSchemaAction$: (type: SchemaImportType, value: string) => GeneratorAction;
 export declare const loadSchemaSQLAction$: (value: string) => GeneratorAction;
 export declare const loadSchemaGraphQLAction$: (value: string) => GeneratorAction;
 export declare const loadSchemaDBMLAction$: (value: string) => GeneratorAction;
@@ -45,20 +141,23 @@ export declare const actions$: {
     focusFlowTableAction$: (tableIds: string[]) => GeneratorAction;
     loadJsonAction$: (value: string) => GeneratorAction;
     initialLoadJsonAction$: (value: string) => GeneratorAction;
-    moveAllAction$: (movementX: number, movementY: number, source?: GeometrySource) => GeneratorAction;
+    moveAllAction$: (movementX: number, movementY: number, source?: GeometrySource, gesture?: MoveAllGesture) => GeneratorAction;
     removeSelectedAction$: () => GeneratorAction;
     pasteEntitiesAction$: (payload: ClipboardPayload, pasteRound: number) => GeneratorAction;
     duplicateAction$: ({ tableIds, memoIds, offset, escapeCollision, }: DuplicateConfig) => GeneratorAction;
-    dragSelectAction$: (dragRect: Rect, source?: GeometrySource) => GeneratorAction;
+    dragSelectAction$: (dragRect: DragRect, source?: GeometrySource) => GeneratorAction;
     unselectAllAction$: () => GeneratorAction;
     focusMoveTableAction$: (moveKey: MoveKey, shiftKey: boolean) => GeneratorAction;
     drawStartRelationshipAction$: (relationshipType: number) => GeneratorAction;
     drawStartAddRelationshipAction$: (tableId: string) => GeneratorAction;
     changeColorAllAction$: (color: string) => GeneratorAction;
+    removeColorAllAction$: () => GeneratorAction;
     loadSchemaSQLAction$: (value: string) => GeneratorAction;
     loadSchemaGraphQLAction$: (value: string) => GeneratorAction;
     loadSchemaDBMLAction$: (value: string) => GeneratorAction;
     loadSchemaAMLAction$: (value: string) => GeneratorAction;
+    appendSchemaAction$: (type: SchemaImportType, value: string) => GeneratorAction;
+    appendSchemaJsonAction$: (json: string, layout?: AppendLayout) => GeneratorAction;
     dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
     dragoverColumnAction$: (targetId: string | null, targetTableId: string) => GeneratorAction;
     columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;

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

@@ -15,6 +15,8 @@ export type Editor = {
     focusTable: FocusTable | null;
     /** The memo whose body an overlay editor is open on, and null while none is. */
     editMemoId: string | null;
+    /** The table group whose name an overlay editor is open on, and null while none is. */
+    editTableGroupId: string | null;
     /**
      * How far down its body each memo is shown from, by memo id. The scene and
      * the overlay editor both read it, so the lines a body shows survive the
@@ -27,6 +29,11 @@ export type Editor = {
     openMap: Record<string, boolean>;
     /** Whether the pointer pans the canvas instead of reaching the scene under it. */
     handTool: boolean;
+    /**
+     * Whether the next main press on the canvas draws a table group instead of
+     * reaching the scene under it. Local to this client, never the file or a peer.
+     */
+    drawTableGroup: boolean;
     /** Whether the editor is drawn without its scrollbars, its map and its toolbar. */
     zenMode: boolean;
     draggableColumn: DraggableColumn | null;
@@ -44,6 +51,11 @@ export type Editor = {
     views: EditorViews;
     /** Which of its two modes the visualization tab shows. Remembered for the session. */
     visualizationMode: VisualizationMode;
+    /**
+     * The last tab the reader left for another, Settings never among them: the
+     * one a canvas type lock taken on the Settings tab holds.
+     */
+    lastCanvasType: string;
 };
 export type Viewport = {
     width: number;
@@ -96,6 +108,7 @@ export type SharedDragSelectTracker = Rect & {
 export declare const SelectType: {
     readonly table: "table";
     readonly memo: "memo";
+    readonly tableGroup: "tableGroup";
 };
 export type SelectType = ValuesType<typeof SelectType>;
 export declare const ShowMode: {
@@ -159,9 +172,9 @@ export declare const hasMoveKeys: (value: string) => boolean;
  */
 export declare const isEditingMemo: ({ editMemoId }: Editor) => boolean;
 /**
- * Whether a live text editor owns the keyboard. A memo body and a table cell
- * both open a real input over the scene, so a canvas shortcut stands down for
- * either of them rather than for the cell alone.
+ * Whether a live text editor owns the keyboard. A memo body, a table cell and a
+ * table group's name each open a real input over the scene, so a canvas
+ * shortcut stands down for any of them rather than for the cell alone.
  */
 export declare const isEditingText: (editor: Editor) => boolean;
 export declare const createEditor: () => Editor;

package/dist/engine/modules/editor/utils/color.d.ts

@@ -0,0 +1,21 @@
+import { RootState } from '../../../state';
+import { Memo, Table, TableGroup } from '../../../../internal-types';
+type ColorTargets = {
+    tables: Table[];
+    memos: Memo[];
+    tableGroups: TableGroup[];
+};
+/** The selected tables, memos and table groups, the whole of what the color picker paints. */
+export declare function getColorTargets({ editor: { selectedMap }, collections, }: RootState): ColorTargets;
+/** The color targets that carry a color, which is all Remove color reaches. */
+export declare function getColoredSelection(state: RootState): ColorTargets;
+/** Whether any selected table, memo or group carries a color, which the menus' Remove color shows on. */
+export declare function hasColoredSelection(state: RootState): boolean;
+/**
+ * The colors the document's tables, memos and table groups carry as opaque
+ * #rrggbb, the most used first and a tie in document order; one it cannot
+ * read is left out.
+ */
+export declare function getDocumentColors({ doc, collections }: RootState): string[];
+export {};
+//# sourceMappingURL=color.d.ts.map

package/dist/engine/modules/editor/utils/duplicate.d.ts

@@ -1,16 +1,43 @@
 import { AnyAction } from '@dineug/r-html';
 import { ClipboardColumn, ClipboardIndex, ClipboardMemo, ClipboardRelationship, ClipboardTable, PlacementPoint } from '../../../../utils/table-clipboard';
+/**
+ * A table group a document brings, its rect where it lands and the source ids
+ * of the tables it holds, which no clipboard payload carries.
+ */
+export type CreateEntityTableGroup = {
+    sourceId: string;
+    name: string;
+    color: string;
+    tableIds: string[];
+    ui: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zIndex: number;
+    };
+};
 export type CreateEntityInput = {
     tables: ClipboardTable[];
     columns: ClipboardColumn[];
     memos: ClipboardMemo[];
     relationships: ClipboardRelationship[];
     indexes: ClipboardIndex[];
+    tableGroups?: CreateEntityTableGroup[];
 };
 export type CreateEntityActions = {
     actions: AnyAction[];
     tableIds: string[];
     memoIds: string[];
+    tableGroupIds: string[];
+};
+export type CreateEntityOptions = {
+    /**
+     * Whether a field is set only when it holds something other than what a new
+     * entity starts with, an empty text, a flag off or an ascending order, which
+     * leaves the same entities in fewer actions.
+     */
+    valuesOnly?: boolean;
 };
-export declare function toCreateEntityActions({ tables, columns, memos, relationships, indexes }: CreateEntityInput, placement: Map<string, PlacementPoint>): CreateEntityActions;
+export declare function toCreateEntityActions({ tables, columns, memos, relationships, indexes, tableGroups, }: CreateEntityInput, placement: Map<string, PlacementPoint>, { valuesOnly }?: CreateEntityOptions): CreateEntityActions;
 //# sourceMappingURL=duplicate.d.ts.map

package/dist/engine/modules/editor/utils/focus.d.ts

@@ -6,6 +6,22 @@ export declare function isColumns({ collections, editor: { focusTable } }: RootS
 export declare function isLastColumn(state: RootState): boolean;
 export declare function isLastRowColumn({ collections, editor: { focusTable }, }: RootState): boolean;
 export declare function getRemoveFirstColumnId(state: RootState, columnIds: string[]): string | null;
+/**
+ * The columns a command on the focused column reaches: the selection still in
+ * the table when the focused column is one of two or more of it, else that
+ * column alone. A column removed by a peer, an agent or an undo stays selected.
+ */
+export declare function getFocusedColumnIds({ editor: { focusTable }, collections, }: RootState): string[];
+export type RemovableColumns = {
+    tableId: string;
+    columnIds: string[];
+};
+/**
+ * The columns Delete removes: those selected and still in the focused table
+ * while it is the one table, memo or group selected and the zoom draws its
+ * rows. Null otherwise, where the selected tables, memos and groups go instead.
+ */
+export declare function getRemovableColumns({ doc: { tableIds, memoIds, tableGroupIds }, editor: { focusTable, selectedMap }, settings: { zoomLevel }, collections, }: RootState): RemovableColumns | null;
 export declare function isLastTable(state: RootState): boolean;
 export declare const isTableFocusType: (value: FocusType) => boolean;
 export declare function arrowUp(state: RootState, payload: Payload): void;

package/dist/engine/modules/editor/utils/releaseHidden.d.ts

@@ -0,0 +1,16 @@
+import { RootState } from '../../../state';
+/**
+ * Hidden groups take no press, so hiding them lets go of every selected group,
+ * ends a draw armed and closes a name editor, none of which a reader could see
+ * or end any longer.
+ */
+export declare function releaseTableGroups(state: RootState): void;
+/** Hidden memos take no press either, so hiding them lets go of every selected memo and closes a memo editor. */
+export declare function releaseMemos(state: RootState): void;
+/**
+ * Lets go of what the show bits a load landed hide, as hiding them by View
+ * Option does, so an undo, an import or a peer's load that hides them leaves
+ * no selection or editor on what no reader can see.
+ */
+export declare function releaseHidden(state: RootState): void;
+//# sourceMappingURL=releaseHidden.d.ts.map

package/dist/engine/modules/editor/utils/selection.d.ts

@@ -0,0 +1,12 @@
+import { SelectType } from '../state';
+export type SelectTypeIds = {
+    tableIds: string[];
+    memoIds: string[];
+    tableGroupIds: string[];
+};
+/**
+ * The selected tables', memos' and table groups' ids apart, in selection
+ * order: one split for the move and the color picker, so both reach the same.
+ */
+export declare function getSelectTypeIds(selectedMap: Record<string, SelectType>): SelectTypeIds;
+//# sourceMappingURL=selection.d.ts.map

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

@@ -8,6 +8,7 @@ export declare const ActionType: {
     readonly changeRelationshipType: "relationship.changeType";
     readonly changeRelationshipOnDelete: "relationship.changeOnDelete";
     readonly changeRelationshipOnUpdate: "relationship.changeOnUpdate";
+    readonly changeRelationshipColumns: "relationship.changeColumns";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 export type ActionMap = {
@@ -35,6 +36,11 @@ export type ActionMap = {
         id: string;
         value: number;
     };
+    [ActionType.changeRelationshipColumns]: {
+        id: string;
+        start: RelationshipPoint;
+        end: RelationshipPoint;
+    };
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
 type RelationshipPoint = {