@dineug/erd-editor 4.1.0 → 4.2.0

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

@@ -1,10 +1,21 @@
+import { DictionaryKind } from '../dictionary/actions';
 import { Point, ValuesType } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
+/** Whether a history can undo and redo. */
+export type HasHistory = {
+    hasUndo: boolean;
+    hasRedo: boolean;
+};
 export type Editor = {
     id: string;
     selectedMap: Record<string, SelectType>;
     hasUndo: boolean;
     hasRedo: boolean;
+    /**
+     * Whether each dictionary sheet's own history can undo and redo: the Dictionary
+     * tab's edits go there, never into the document's (hasUndo, hasRedo).
+     */
+    dictionaryHistory: Record<DictionaryKind, HasHistory>;
     viewport: Viewport;
     /**
      * Whether a loaded origin still waits to be pulled into the content's travel
@@ -126,6 +137,12 @@ export declare const VisualizationMode: {
     readonly flow: "flow";
 };
 export type VisualizationMode = ValuesType<typeof VisualizationMode>;
+/** Which way a view steps through the centers it has stood on. */
+export declare const CenterStep: {
+    readonly previous: "previous";
+    readonly next: "next";
+};
+export type CenterStep = ValuesType<typeof CenterStep>;
 /**
  * A scene drawn over the document in its own coordinates: the tables it places
  * by id, the placement it is looked at through, and what it shows of each
@@ -140,6 +157,10 @@ export type SceneView = {
     zoomLevel: number;
     /** The tables the view narrows to, and none while it shows the whole document. */
     centerIds: string[];
+    /** The centers it stood on before these, the latest last, which a step back returns to. */
+    previousCenterIds: string[][];
+    /** The centers a step back left, the latest last, which a step forward returns to. */
+    nextCenterIds: string[][];
 };
 export type EditorViews = {
     flow: SceneView | null;
@@ -154,6 +175,9 @@ export declare const FocusType: {
     readonly columnAutoIncrement: "columnAutoIncrement";
     readonly columnDefault: "columnDefault";
     readonly columnComment: "columnComment";
+    readonly tableLogicalName: "tableLogicalName";
+    readonly columnLogicalName: "columnLogicalName";
+    readonly columnDomain: "columnDomain";
 };
 export type FocusType = ValuesType<typeof FocusType>;
 export declare const MoveKey: {

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

@@ -0,0 +1,103 @@
+import { FocusType } from '../state';
+import { RootState } from '../../../state';
+import { Column } from '../../../../internal-types';
+import { GeometrySource } from '../../../../utils/draw-relationship/geometrySource';
+type Settings = RootState['settings'];
+type ViewSettings = Pick<Settings, 'nameViewMode' | 'show'>;
+/**
+ * The name view and the show bits a scene lays its cells out by: the document's
+ * settings, and in a view the name view alone, since a view reads no show bit.
+ * So a view's type cell stands for the domain in the logical view whatever the Domain bit says.
+ */
+export declare const sceneNameSettings: (settings: ViewSettings, source?: GeometrySource) => ViewSettings;
+/** Whether the document draws each logical name in the place of its name. */
+export declare const isLogicalNameView: ({ nameViewMode, }: Pick<Settings, "nameViewMode">) => boolean;
+/** Whether the document draws each logical name beside its name. */
+export declare const isBothNameView: ({ nameViewMode, }: Pick<Settings, "nameViewMode">) => boolean;
+/**
+ * Whether a logical name cell draws the name in its place: in the logical
+ * view while the logical name is blank, dimmed, and measured by the name.
+ */
+export declare const drawsNameForLogicalName: (settings: Pick<Settings, "nameViewMode">, { logicalName }: {
+    logicalName: string;
+}) => boolean;
+/** What a label outside the canvas shows of a table's or a column's names. */
+export type NameLabel = {
+    /** The name it leads with, blank while there is none to show. */
+    text: string;
+    /** The name after it, muted where it can be: the view of both's own, '' otherwise. */
+    after: string;
+    /** Whether the text is the name standing in for a blank logical name, which a label dims. */
+    standIn: boolean;
+};
+/**
+ * What a label shows in the name view: the logical name in the logical view,
+ * the name standing in while it is blank, and in the view of both the logical
+ * name with the name after it, or the name alone while the logical one is blank.
+ */
+export declare function toNameLabel(settings: Pick<Settings, 'nameViewMode'>, { name, logicalName }: {
+    name: string;
+    logicalName: string;
+}): NameLabel;
+/**
+ * A label as one text, where it cannot set its names apart: the name after
+ * the logical name stands in brackets.
+ *
+ * @example
+ * nameLabelText({ text: 'Member', after: 'member', standIn: false }); // 'Member (member)'
+ */
+export declare const nameLabelText: ({ text, after }: NameLabel) => string;
+/**
+ * Whether a document row's type cell stands for its domain: in the logical
+ * view while the domain has no cell of its own, so a row never draws the
+ * domain twice. It then shows the domain's name, or the type while it has none.
+ */
+export declare const isDomainInTypeCell: (settings: ViewSettings) => boolean;
+/**
+ * Whether one row's type cell draws its column's domain: while the cell stands
+ * for the domain in the source's scene and the column links one the document
+ * lists by a name. Otherwise it draws the type, and is measured by it.
+ */
+export declare const drawsDomainInTypeCell: (state: RootState, column: Pick<Column, "domainId">, source?: GeometrySource) => boolean;
+/**
+ * The cells a document table header lays out, in order: the name, the
+ * logical name in its place in the logical view or before it in the view of
+ * both, then the comment while it shows.
+ */
+export declare function getTableFocusTypes(settings: ViewSettings): FocusType[];
+/**
+ * Whether a document row lays out the cell of each column type: the name
+ * always, the logical name in the view of both names alone, and every other
+ * cell, the domain among them, while its show bit is set.
+ */
+export declare const ColumnTypeShown: Readonly<Record<number, (settings: ViewSettings) => boolean>>;
+/**
+ * The focus a document cell takes in the name view, given the one it takes in
+ * the physical view: the logical view edits the logical name in the name cell
+ * and, while the type cell stands for the domain, the domain there.
+ */
+export declare function toNameViewFocusType(settings: ViewSettings, focusType: FocusType): FocusType;
+/** The focus types of a document row's cells, in the order the settings put them. */
+export declare function getColumnFocusTypes(settings: Pick<Settings, 'nameViewMode' | 'show' | 'columnOrder'>): FocusType[];
+/**
+ * The cells a view row lays out, whatever the show bits or the column order:
+ * the name and the type, which the logical view fills its own way, and in the
+ * view of both the logical name before them and the domain before the type.
+ */
+export declare function getViewColumnTypes(settings: Pick<Settings, 'nameViewMode'>): number[];
+/** The focus types of a view row's cells, in that order. */
+export declare function getViewColumnFocusTypes(settings: ViewSettings): FocusType[];
+/**
+ * Where a header or a row of the given cells shows a focus type: on its own
+ * cell, else on the cell the name view draws in its place, the name and the
+ * logical name standing in for each other, as the type and the domain do.
+ */
+export declare function toShownFocusType(settings: ViewSettings, types: ReadonlyArray<FocusType>, focusType: FocusType): FocusType | null;
+/**
+ * Moves the focus onto the cell that shows it once the name view or the Domain
+ * bit changed, the logical name's cell for the name's, and closes an editor it
+ * moves off. A focus neither cell of its pair shows is left as a hidden bit leaves it.
+ */
+export declare function keepFocusShown(state: RootState): void;
+export {};
+//# sourceMappingURL=nameView.d.ts.map

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

@@ -1,5 +1,5 @@
 import { ReducerType } from './actions';
-import { Editor, ViewKind } from './state';
+import { CenterStep, Editor, ViewKind } from './state';
 /** Drops the view, which is what any replacement of the document owes it. */
 export declare function clearViews(editor: Editor): void;
 export declare const viewOpenAction: {
@@ -118,6 +118,17 @@ export declare const viewSetCentersAction: {
     toString(): string;
     type: string;
 };
+export declare const viewStepCentersAction: {
+    (payload: {
+        step: CenterStep;
+        kind?: ViewKind;
+    }): import('@dineug/r-html').AnyAction<{
+        step: CenterStep;
+        kind?: ViewKind;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const changeVisualizationModeAction: {
     (payload: {
         value: import('./state').VisualizationMode;
@@ -138,6 +149,7 @@ export declare const viewReducers: {
     "editor.viewSetLayout": ReducerType<"editor.viewSetLayout">;
     "editor.viewChangeShowMode": ReducerType<"editor.viewChangeShowMode">;
     "editor.viewSetCenters": ReducerType<"editor.viewSetCenters">;
+    "editor.viewStepCenters": ReducerType<"editor.viewStepCenters">;
     "editor.changeVisualizationMode": ReducerType<"editor.changeVisualizationMode">;
 };
 export declare const viewActions: {
@@ -257,6 +269,17 @@ export declare const viewActions: {
         toString(): string;
         type: string;
     };
+    viewStepCentersAction: {
+        (payload: {
+            step: CenterStep;
+            kind?: ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            step: CenterStep;
+            kind?: ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
     changeVisualizationModeAction: {
         (payload: {
             value: import('./state').VisualizationMode;

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

@@ -19,6 +19,14 @@ export declare const isViewShown: (state: RootState, kind: ViewSource) => boolea
  * 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;
+/** Whether two center sets name the same tables in the same order, which frame a view alike. */
+export declare const isSameCenters: (a: string[], b: string[]) => boolean;
+/**
+ * What a step to the centers given stands the view on: those of the tables given
+ * that it names, none standing for the whole document. Null where the step passes
+ * them over, all their tables gone or what is left the centers the view stands on.
+ */
+export declare function toSteppedCenters(tableIds: ReadonlySet<string>, view: SceneView, centerIds: string[]): string[] | 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

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

@@ -3,12 +3,18 @@ import { RootState } from '../../state';
 import { Column, Table } from '../../../internal-types';
 /**
  * The start table's name and the names the end table's columns hold, which
- * name the copies, and the document's database, which types a serial key's copy.
+ * name the copies, the document's database, which types a serial key's copy,
+ * and its domains, which the copies link.
  */
 export type ForeignKeyContext = {
     startTableName: string;
     endColumnNames: string[];
     database: number;
+    /**
+     * The document's domain list: a copy links its start column's domain while
+     * the list holds it and toReferenceDataType leaves the type as it was.
+     */
+    domainIds?: string[];
 };
 /**
  * The columns a relationship drawn from a table copies into the table it ends
@@ -38,8 +44,8 @@ export declare function prefixKeyName(tableName: string, keyName: string): strin
 export declare function toForeignKeyNames(startTableName: string, keyNames: string[], endColumnNames: string[]): string[];
 /**
  * Adds a NOT NULL copy of each start column to the end table under the id at
- * the same index of endColumnIds, named by toForeignKeyNames, typed by
- * toReferenceDataType, with its default and comment. The caller owns the ids.
+ * the same index of endColumnIds, named by toForeignKeyNames and typed by
+ * toReferenceDataType, with its default, comment, logical name and domain.
  */
-export declare const toForeignKeyActions: (startColumns: Column[], endTableId: string, endColumnIds: string[], { startTableName, endColumnNames, database }: ForeignKeyContext) => AnyAction[];
+export declare const toForeignKeyActions: (startColumns: Column[], endTableId: string, endColumnIds: string[], { startTableName, endColumnNames, database, domainIds, }: ForeignKeyContext) => AnyAction[];
 //# sourceMappingURL=fkColumns.d.ts.map

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

@@ -1,5 +1,5 @@
 import { Reducer } from '@dineug/r-html';
-import { DDLScriptPosition } from '../../../constants/schema';
+import { DDLScriptPosition, NameViewMode } from '../../../constants/schema';
 import { EngineContext } from '../../context';
 import { RootState } from '../../state';
 import { ValuesType } from '../../../internal-types';
@@ -22,6 +22,7 @@ export declare const ActionType: {
     readonly changeLockSettings: "settings.changeLockSettings";
     readonly changeIgnoreSaveSettings: "settings.changeIgnoreSaveSettings";
     readonly changeDDLScript: "settings.changeDDLScript";
+    readonly changeNameViewMode: "settings.changeNameViewMode";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 export type ActionMap = {
@@ -79,8 +80,8 @@ export type ActionMap = {
         value: boolean;
         /**
          * The settings named as the sending store shows them: a lock holds them,
-         * and an unlock shows the code settings among them on every peer, so each
-         * saves one value. The viewport and the tab carry none to unlock.
+         * and an unlock shows the code settings and the name view among them on
+         * every peer, so each saves one value. The viewport and the tab carry none.
          */
         values: Partial<RootState['settings']['lockedValues']>;
     };
@@ -92,6 +93,15 @@ export type ActionMap = {
         position: ValuesType<typeof DDLScriptPosition>;
         value: string;
     };
+    [ActionType.changeNameViewMode]: {
+        value: ValuesType<typeof NameViewMode>;
+        /**
+         * Whether every peer takes it: the sender's lock was off and it could
+         * edit. Otherwise only the store whose editor sent it shows it.
+         */
+        shared: boolean;
+        editorId: string;
+    };
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
 //# sourceMappingURL=actions.d.ts.map

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

@@ -1,6 +1,7 @@
+import { NameViewMode } from '../../../constants/schema';
 import { Viewport } from '../editor/state';
 import { RootState } from '../../state';
-import { Point } from '../../../internal-types';
+import { Point, ValuesType } from '../../../internal-types';
 import { GeometrySource } from '../../../utils/draw-relationship/geometrySource';
 import { ActionMap, ActionType, ReducerType } from './actions';
 import { ScrollRange } from './scrollRange';
@@ -212,6 +213,11 @@ export declare const changeLockSettingsAction: {
  * never following-tagged, so an unlock of one carries the unlocker's value.
  */
 export declare const CodeLockSettings: number;
+/**
+ * The locks whose unlock carries the unlocker's value onto every peer: the
+ * code settings, and the name view each reader held as its own while locked.
+ */
+export declare const UnlockCarriedSettings: number;
 export declare const changeIgnoreSaveSettingsAction: {
     (payload: {
         saveSettingType: number;
@@ -225,15 +231,39 @@ export declare const changeIgnoreSaveSettingsAction: {
 };
 export declare const changeDDLScriptAction: {
     (payload: {
-        position: import('../../../internal-types').ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
+        position: ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
         value: string;
     }): import('@dineug/r-html').AnyAction<{
-        position: import('../../../internal-types').ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
+        position: ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
         value: string;
     }>;
     toString(): string;
     type: string;
 };
+type NameViewModeValue = ValuesType<typeof NameViewMode>;
+export declare const changeNameViewModeAction: {
+    (payload: {
+        value: ValuesType<typeof NameViewMode>;
+        shared: boolean;
+        editorId: string;
+    }): import('@dineug/r-html').AnyAction<{
+        value: ValuesType<typeof NameViewMode>;
+        shared: boolean;
+        editorId: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+/**
+ * The switch a reader makes: shared while the lock is off and the store may
+ * edit, its own screen otherwise. The caller passes the store's readonly flag,
+ * which no state holds.
+ */
+export declare const toNameViewModeAction: (state: RootState, value: NameViewModeValue, readonly: boolean) => import('@dineug/r-html').AnyAction<{
+    value: ValuesType<typeof NameViewMode>;
+    shared: boolean;
+    editorId: string;
+}>;
 /**
  * Lands the settings of a load that replaces the document: each lock through
  * its register, a bit no lock owns taken from the load as show is, and each
@@ -259,6 +289,7 @@ export declare const settingsReducers: {
     "settings.changeLockSettings": ReducerType<"settings.changeLockSettings">;
     "settings.changeIgnoreSaveSettings": ReducerType<"settings.changeIgnoreSaveSettings">;
     "settings.changeDDLScript": ReducerType<"settings.changeDDLScript">;
+    "settings.changeNameViewMode": ReducerType<"settings.changeNameViewMode">;
 };
 export declare const actions: {
     changeDatabaseNameAction: {
@@ -430,14 +461,27 @@ export declare const actions: {
     };
     changeDDLScriptAction: {
         (payload: {
-            position: import('../../../internal-types').ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
+            position: ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
             value: string;
         }): import('@dineug/r-html').AnyAction<{
-            position: import('../../../internal-types').ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
+            position: ValuesType<typeof import('../../../constants/schema').DDLScriptPosition>;
             value: string;
         }>;
         toString(): string;
         type: string;
     };
+    changeNameViewModeAction: {
+        (payload: {
+            value: ValuesType<typeof NameViewMode>;
+            shared: boolean;
+            editorId: string;
+        }): import('@dineug/r-html').AnyAction<{
+            value: ValuesType<typeof NameViewMode>;
+            shared: boolean;
+            editorId: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
 };
 //# sourceMappingURL=atom.actions.d.ts.map

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

@@ -20,8 +20,8 @@ export type PinchZoom = {
 export declare const pinchZoomAction$: ({ zoomLevel, screen, scene }: PinchZoom, source?: GeometrySource) => GeneratorAction;
 /**
  * Locks the settings named at what they hold now, or unlocks them carrying the
- * code settings among them as they show here. A canvas type locked on the
- * Settings tab holds the tab the reader came from.
+ * code settings and the name view among them as they show here. A canvas type
+ * locked on the Settings tab holds the tab the reader came from.
  */
 export declare const changeLockSettingsAction$: (lockSettingType: number, value: boolean) => GeneratorAction;
 export declare const actions$: {

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

@@ -13,6 +13,8 @@ export declare const ActionType: {
     readonly changeTableGroup: "table.changeGroup";
     readonly changeZIndex: "table.changeZIndex";
     readonly sortTable: "table.sort";
+    readonly changeTableLogicalName: "table.changeLogicalName";
+    readonly changeTableNameDerived: "table.changeNameDerived";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 export type ActionMap = {
@@ -57,6 +59,11 @@ export type ActionMap = {
         zIndex: number;
     };
     [ActionType.sortTable]: void;
+    [ActionType.changeTableLogicalName]: ChangeTableValuePayload;
+    [ActionType.changeTableNameDerived]: {
+        id: string;
+        value: boolean;
+    };
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
 type ChangeTableValuePayload = {

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

@@ -66,6 +66,28 @@ export declare const changeTableNameAction: {
     toString(): string;
     type: string;
 };
+export declare const changeTableLogicalNameAction: {
+    (payload: {
+        id: string;
+        value: string;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        value: string;
+    }>;
+    toString(): string;
+    type: string;
+};
+export declare const changeTableNameDerivedAction: {
+    (payload: {
+        id: string;
+        value: boolean;
+    }): import('@dineug/r-html').AnyAction<{
+        id: string;
+        value: boolean;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const changeTableCommentAction: {
     (payload: {
         id: string;
@@ -132,6 +154,8 @@ export declare const tableReducers: {
     "table.changeGroup": ReducerType<"table.changeGroup">;
     "table.changeZIndex": ReducerType<"table.changeZIndex">;
     "table.sort": ReducerType<"table.sort">;
+    "table.changeLogicalName": ReducerType<"table.changeLogicalName">;
+    "table.changeNameDerived": ReducerType<"table.changeNameDerived">;
 };
 export declare const actions: {
     addTableAction: {
@@ -256,5 +280,27 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    changeTableLogicalNameAction: {
+        (payload: {
+            id: string;
+            value: string;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            value: string;
+        }>;
+        toString(): string;
+        type: string;
+    };
+    changeTableNameDerivedAction: {
+        (payload: {
+            id: string;
+            value: boolean;
+        }): import('@dineug/r-html').AnyAction<{
+            id: string;
+            value: boolean;
+        }>;
+        toString(): string;
+        type: string;
+    };
 };
 //# sourceMappingURL=atom.actions.d.ts.map

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

@@ -10,11 +10,18 @@ export declare const pasteTableAction$: (columns: Column[]) => GeneratorAction;
  * table.sort measures each replica's own text; placed points agree everywhere.
  */
 export declare const sortTablesToMoveAction$: () => GeneratorAction;
+/**
+ * Renames a table as typed by hand, so the dictionaries leave a name that is
+ * not empty alone from then on: the derived flag goes off in the same dispatch
+ * while it is on.
+ */
+export declare const changeTableNameAction$: (id: string, value: string) => GeneratorAction;
 export declare const actions$: {
     addTableAction$: () => GeneratorAction;
     removeTableAction$: (id?: string) => GeneratorAction;
     selectTableAction$: (id: string, $mod: boolean) => GeneratorAction;
     pasteTableAction$: (columns: Column[]) => GeneratorAction;
     sortTablesToMoveAction$: () => GeneratorAction;
+    changeTableNameAction$: (id: string, value: string) => GeneratorAction;
 };
 //# sourceMappingURL=generator.actions.d.ts.map

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

@@ -7,6 +7,8 @@ export declare const tablePushUndoHistoryMap: {
     "table.changeGroup": PushUndoHistory;
     "table.moveTo": PushUndoHistory;
     "table.sort": PushUndoHistory;
+    "table.changeLogicalName": PushUndoHistory;
+    "table.changeNameDerived": PushUndoHistory;
 };
 export declare const tablePushStreamHistoryMap: {
     "table.move": PushStreamHistory;

package/dist/engine/modules/table-column/actions.d.ts

@@ -14,6 +14,9 @@ export declare const ActionType: {
     readonly changeColumnUnique: "column.changeUnique";
     readonly changeColumnNotNull: "column.changeNotNull";
     readonly moveColumn: "column.move";
+    readonly changeColumnLogicalName: "column.changeLogicalName";
+    readonly changeColumnDomain: "column.changeDomain";
+    readonly changeColumnNameDerived: "column.changeNameDerived";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 export type ActionMap = {
@@ -38,6 +41,10 @@ export type ActionMap = {
         tableId: string;
         targetId: string;
     };
+    [ActionType.changeColumnLogicalName]: ChangeColumnValuePayload;
+    /** The id of the domain the column links, '' for none. */
+    [ActionType.changeColumnDomain]: ChangeColumnValuePayload;
+    [ActionType.changeColumnNameDerived]: ChangeColumnOptionPayload;
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
 export type ChangeColumnValuePayload = {

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

@@ -93,6 +93,29 @@ export declare const changeColumnNotNullAction: {
     toString(): string;
     type: string;
 };
+export declare const changeColumnLogicalNameAction: {
+    (payload: import('./actions').ChangeColumnValuePayload): import('@dineug/r-html').AnyAction<import('./actions').ChangeColumnValuePayload>;
+    toString(): string;
+    type: string;
+};
+export declare const changeColumnDomainAction: {
+    (payload: import('./actions').ChangeColumnValuePayload): import('@dineug/r-html').AnyAction<import('./actions').ChangeColumnValuePayload>;
+    toString(): string;
+    type: string;
+};
+export declare const changeColumnNameDerivedAction: {
+    (payload: {
+        tableId: string;
+        id: string;
+        value: boolean;
+    }): import('@dineug/r-html').AnyAction<{
+        tableId: string;
+        id: string;
+        value: boolean;
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const moveColumnAction: {
     (payload: {
         id: string;
@@ -118,6 +141,9 @@ export declare const tableColumnReducers: {
     "column.changeUnique": ReducerType<"column.changeUnique">;
     "column.changeNotNull": ReducerType<"column.changeNotNull">;
     "column.move": ReducerType<"column.move">;
+    "column.changeLogicalName": ReducerType<"column.changeLogicalName">;
+    "column.changeDomain": ReducerType<"column.changeDomain">;
+    "column.changeNameDerived": ReducerType<"column.changeNameDerived">;
 };
 export declare const actions: {
     addColumnAction: {
@@ -227,5 +253,28 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    changeColumnLogicalNameAction: {
+        (payload: import('./actions').ChangeColumnValuePayload): import('@dineug/r-html').AnyAction<import('./actions').ChangeColumnValuePayload>;
+        toString(): string;
+        type: string;
+    };
+    changeColumnDomainAction: {
+        (payload: import('./actions').ChangeColumnValuePayload): import('@dineug/r-html').AnyAction<import('./actions').ChangeColumnValuePayload>;
+        toString(): string;
+        type: string;
+    };
+    changeColumnNameDerivedAction: {
+        (payload: {
+            tableId: string;
+            id: string;
+            value: boolean;
+        }): import('@dineug/r-html').AnyAction<{
+            tableId: string;
+            id: string;
+            value: boolean;
+        }>;
+        toString(): string;
+        type: string;
+    };
 };
 //# sourceMappingURL=atom.actions.d.ts.map

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

@@ -6,6 +6,11 @@ export declare const isChangeColumnTypes: (value: FocusType) => boolean;
 export declare const addColumnAction$: (tableId?: string) => GeneratorAction;
 export declare const removeColumnAction$: (tableId: string, columnIds: string[]) => GeneratorAction;
 export declare const toggleColumnValueAction$: (focusType: FocusType, tableId: string, columnId: string) => GeneratorAction;
+/**
+ * Writes a column's type as typed, with what the data type sync spreads from
+ * it, and unlinks in the same dispatch each written column, a foreign key the
+ * sync reached included, off the type of its domain, listed or removed.
+ */
 export declare const changeColumnDataTypeAction$: (payload: ChangeColumnValuePayload) => GeneratorAction;
 export declare const changeColumnValueAction$: (focusType: FocusType, tableId: string, columnId: string, value: string) => GeneratorAction;
 /**

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

@@ -11,5 +11,8 @@ export declare const tableColumnPushUndoHistoryMap: {
     "column.changePrimaryKey": PushUndoHistory;
     "column.changeUnique": PushUndoHistory;
     "column.move": PushUndoHistory;
+    "column.changeLogicalName": PushUndoHistory;
+    "column.changeDomain": PushUndoHistory;
+    "column.changeNameDerived": PushUndoHistory;
 };
 //# sourceMappingURL=history.d.ts.map

package/dist/engine/modules/table-column/utils/dataType.d.ts

@@ -16,7 +16,9 @@ export type DataTypeSyncRelationship = {
  *
  * @param relationships The relationships to follow, the document's by default;
  * a caller about to change one hands the list as it will stand.
+ * @param settledIds The columns the batch writes a type of their own, which the
+ * walk starts from and never writes again, so no stack order decides them.
  */
-export declare function getDataTypeSyncColumns(stack: ChangeColumnValuePayload[], state: RootState, payloads?: ChangeColumnValuePayload[], relationships?: DataTypeSyncRelationship[]): ChangeColumnValuePayload[];
+export declare function getDataTypeSyncColumns(stack: ChangeColumnValuePayload[], state: RootState, payloads?: ChangeColumnValuePayload[], relationships?: DataTypeSyncRelationship[], settledIds?: ReadonlySet<string>): ChangeColumnValuePayload[];
 export {};
 //# sourceMappingURL=dataType.d.ts.map