@dineug/erd-editor 4.0.0 → 4.2.0

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

@@ -1,9 +1,10 @@
 import { Reducer } from '@dineug/r-html';
 import { EngineContext } from '../../context';
+import { DictionaryKind } from '../dictionary/actions';
 import { RootState } from '../../state';
 import { LWW, Point, ValuesType } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
-import { FocusType, MoveKey, SelectType, SharedFocus, ShowMode, ViewKind, VisualizationMode } from './state';
+import { CenterStep, FocusType, MoveKey, SelectType, SharedFocus, ShowMode, ViewKind, VisualizationMode } from './state';
 export declare const ActionType: {
     readonly changeHasHistory: "editor.changeHasHistory";
     readonly selectAll: "editor.selectAll";
@@ -55,13 +56,23 @@ export declare const ActionType: {
     readonly viewSetLayout: "editor.viewSetLayout";
     readonly viewChangeShowMode: "editor.viewChangeShowMode";
     readonly viewSetCenters: "editor.viewSetCenters";
+    readonly viewStepCenters: "editor.viewStepCenters";
     readonly changeVisualizationMode: "editor.changeVisualizationMode";
 };
 export type ActionType = ValuesType<typeof ActionType>;
+/**
+ * Set on the clear and the load of a schema import, and of their undo, which
+ * leave the store's words, terms and domains and their lists as they are.
+ */
+export type DictionaryLoadFlag = {
+    keepDictionaries?: boolean;
+};
 export type ActionMap = {
     [ActionType.changeHasHistory]: {
         hasUndo: boolean;
         hasRedo: boolean;
+        /** The dictionary sheet whose history this is, none for the document's. */
+        sheet?: DictionaryKind;
     };
     [ActionType.selectAll]: void;
     [ActionType.unselectAll]: void;
@@ -70,8 +81,8 @@ export type ActionMap = {
         width: number;
         height: number;
     };
-    [ActionType.clear]: void;
-    [ActionType.loadJson]: {
+    [ActionType.clear]: DictionaryLoadFlag | void;
+    [ActionType.loadJson]: DictionaryLoadFlag & {
         value: string;
     };
     [ActionType.initialClear]: void;
@@ -206,6 +217,10 @@ export type ActionMap = {
         tableIds: string[];
         kind?: ViewKind;
     };
+    [ActionType.viewStepCenters]: {
+        step: CenterStep;
+        kind?: ViewKind;
+    };
     [ActionType.changeVisualizationMode]: {
         value: VisualizationMode;
     };

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

@@ -6,9 +6,11 @@ export declare const changeHasHistoryAction: {
     (payload: {
         hasUndo: boolean;
         hasRedo: boolean;
+        sheet?: import('../dictionary/actions').DictionaryKind;
     }): import('@dineug/r-html').AnyAction<{
         hasUndo: boolean;
         hasRedo: boolean;
+        sheet?: import('../dictionary/actions').DictionaryKind;
     }>;
     toString(): string;
     type: string;
@@ -40,14 +42,16 @@ export declare const changeViewportAction: {
     type: string;
 };
 export declare const clearAction: {
-    (payload: void): import('@dineug/r-html').AnyAction<void>;
+    (payload: void | import('./actions').DictionaryLoadFlag): import('@dineug/r-html').AnyAction<void | import('./actions').DictionaryLoadFlag>;
     toString(): string;
     type: string;
 };
+/** Whether a clear or a load carries the flag that keeps the dictionaries. */
+export declare const keepsDictionaries: (payload: unknown) => boolean;
 export declare const loadJsonAction: {
-    (payload: {
+    (payload: import('./actions').DictionaryLoadFlag & {
         value: string;
-    }): import('@dineug/r-html').AnyAction<{
+    }): import('@dineug/r-html').AnyAction<import('./actions').DictionaryLoadFlag & {
         value: string;
     }>;
     toString(): string;
@@ -337,6 +341,7 @@ export declare const editorReducers: {
     "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">;
     "editor.changeHasHistory": ReducerType<"editor.changeHasHistory">;
     "editor.selectAll": ReducerType<"editor.selectAll">;
@@ -496,6 +501,17 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    viewStepCentersAction: {
+        (payload: {
+            step: import('./state').CenterStep;
+            kind?: import('./state').ViewKind;
+        }): import('@dineug/r-html').AnyAction<{
+            step: import('./state').CenterStep;
+            kind?: import('./state').ViewKind;
+        }>;
+        toString(): string;
+        type: string;
+    };
     changeVisualizationModeAction: {
         (payload: {
             value: import('./state').VisualizationMode;
@@ -509,9 +525,11 @@ export declare const actions: {
         (payload: {
             hasUndo: boolean;
             hasRedo: boolean;
+            sheet?: import('../dictionary/actions').DictionaryKind;
         }): import('@dineug/r-html').AnyAction<{
             hasUndo: boolean;
             hasRedo: boolean;
+            sheet?: import('../dictionary/actions').DictionaryKind;
         }>;
         toString(): string;
         type: string;
@@ -543,14 +561,14 @@ export declare const actions: {
         type: string;
     };
     clearAction: {
-        (payload: void): import('@dineug/r-html').AnyAction<void>;
+        (payload: void | import('./actions').DictionaryLoadFlag): import('@dineug/r-html').AnyAction<void | import('./actions').DictionaryLoadFlag>;
         toString(): string;
         type: string;
     };
     loadJsonAction: {
-        (payload: {
+        (payload: import('./actions').DictionaryLoadFlag & {
             value: string;
-        }): import('@dineug/r-html').AnyAction<{
+        }): import('@dineug/r-html').AnyAction<import('./actions').DictionaryLoadFlag & {
             value: string;
         }>;
         toString(): string;

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

@@ -8,9 +8,17 @@ 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 { DictionaryLoadFlag } from './actions';
 import { MoveKey } from './state';
 import { CreateEntityActions } from './utils/duplicate';
-export declare const loadJsonAction$: (value: string) => GeneratorAction;
+/**
+ * Replaces the document. A schema import passes keepDictionaries, since its
+ * text holds no dictionary and the store's words, terms and domains stay.
+ *
+ * @example
+ * store.dispatch(loadJsonAction$(json, { keepDictionaries: true }));
+ */
+export declare const loadJsonAction$: (value: string, { keepDictionaries }?: DictionaryLoadFlag) => GeneratorAction;
 export declare const initialLoadJsonAction$: (value: string) => GeneratorAction;
 /**
  * One drag of the selection: the document groups and tables it carries, read at its first step and
@@ -56,9 +64,9 @@ export type SchemaAppend = CreateEntityActions & {
  */
 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.
+ * A document's tables, relationships, indexes and memos as new entities here,
+ * made as a paste makes them, no field at its default and no domain link sent,
+ * a gap under the diagram. Null for unreadable text or a document of nothing.
  *
  * @example
  * const append = toSchemaAppend(state, json, 'grid', ctx);
@@ -125,21 +133,27 @@ export declare function withImportSettings(schema: Pick<ERDEditorSchemaV3, 'sett
 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.
+ * this one, its tables at the points the grid gives them here, while the
+ * words, terms and domains stay, since the text brings none.
  */
 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;
 export declare const loadSchemaAMLAction$: (value: string) => GeneratorAction;
-export declare const dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
+/**
+ * Lifts the focused column, or the whole selection while the focused column is
+ * one of two or more selected in its table, as a table's press lifts the
+ * selected tables.
+ */
+export declare const dragstartColumnAction$: () => GeneratorAction;
 /** A null targetId drops past the last row, which appends. */
 export declare const dragoverColumnAction$: (targetId: string | null, targetTableId: string) => GeneratorAction;
 export declare const columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;
 export declare const columnKeyHoverEndAction$: () => GeneratorAction;
 export declare const actions$: {
     focusFlowTableAction$: (tableIds: string[]) => GeneratorAction;
-    loadJsonAction$: (value: string) => GeneratorAction;
+    loadJsonAction$: (value: string, { keepDictionaries }?: DictionaryLoadFlag) => GeneratorAction;
     initialLoadJsonAction$: (value: string) => GeneratorAction;
     moveAllAction$: (movementX: number, movementY: number, source?: GeometrySource, gesture?: MoveAllGesture) => GeneratorAction;
     removeSelectedAction$: () => GeneratorAction;
@@ -158,7 +172,7 @@ export declare const actions$: {
     loadSchemaAMLAction$: (value: string) => GeneratorAction;
     appendSchemaAction$: (type: SchemaImportType, value: string) => GeneratorAction;
     appendSchemaJsonAction$: (json: string, layout?: AppendLayout) => GeneratorAction;
-    dragstartColumnAction$: ($mod: boolean) => GeneratorAction;
+    dragstartColumnAction$: () => GeneratorAction;
     dragoverColumnAction$: (targetId: string | null, targetTableId: string) => GeneratorAction;
     columnKeyHoverStartAction$: (columnId: string) => GeneratorAction;
     columnKeyHoverEndAction$: () => GeneratorAction;

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 = {