@dineug/erd-editor 4.0.0 → 4.2.0

package/dist/utils/keyboard-shortcut/index.d.ts

@@ -16,6 +16,8 @@ export declare const KeyBindingName: {
     readonly addTable: "addTable";
     readonly addColumn: "addColumn";
     readonly addMemo: "addMemo";
+    readonly addTableGroup: "addTableGroup";
+    readonly groupSelectedTables: "groupSelectedTables";
     readonly removeTable: "removeTable";
     readonly removeColumn: "removeColumn";
     readonly removeSelection: "removeSelection";
@@ -35,18 +37,24 @@ export declare const KeyBindingName: {
     readonly zenMode: "zenMode";
 };
 export type KeyBindingName = ValuesType<typeof KeyBindingName>;
-export declare const KeyBindingNameList: ("undo" | "redo" | "selectAllColumn" | "search" | "stop" | "primaryKey" | "edit" | "addMemo" | "addTable" | "removeTable" | "addColumn" | "removeColumn" | "findReplace" | "removeSelection" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
+export declare const KeyBindingNameList: ("undo" | "redo" | "addColumn" | "removeColumn" | "search" | "stop" | "selectAllColumn" | "primaryKey" | "edit" | "addMemo" | "addTable" | "removeTable" | "addTableGroup" | "findReplace" | "groupSelectedTables" | "removeSelection" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
 /**
  * The chords a press inside a floating panel still carries to the editor:
  * Find and Replace's own, search, the document's undo and redo, and the zoom.
  */
 export declare const PANEL_PASSING_BINDINGS: ReadonlyArray<KeyBindingName>;
 export type KeyBindingMap = Record<KeyBindingName, ShortcutOption[]>;
+/**
+ * Whether a press inside a panel stops there: a press an IME still holds, a
+ * chord of the map outside the passing list, or a key the panel moves or
+ * presses with. A host that leaves Escape to the editor passes stop through.
+ */
+export declare function stopsAtPanel(event: KeyboardEvent, keyBindingMap: KeyBindingMap, passing?: ReadonlyArray<KeyBindingName>): boolean;
 export declare const createKeyBindingMap: () => KeyBindingMap;
 /**
  * Whether the press is one of the chords given, matched as bindKeys matches a
- * press, so a panel reads a binding as the editor root does. A sequence of
- * presses never matches a single one.
+ * press, so a panel reads a binding as the editor root does. Of a sequence it
+ * is the last press, the one that would complete it at the root.
  */
 export declare function matchesShortcut(event: KeyboardEvent, options: ReadonlyArray<ShortcutOption>): boolean;
 export declare function shortcutToTuple(shortcut?: string): KeyBindingPress[];

package/dist/utils/map-columns/alignTypes.d.ts

@@ -14,9 +14,9 @@ export type AlignTypesInput = {
     newColumnIds: string[];
 };
 /**
- * The data type changes that bring each existing child column of the mapping
- * to its parent's, through the data type sync over the relationships as they
- * will stand, while the sync is on; a column already at its value takes none.
+ * While the sync is on, the type changes the sync makes over the relationships
+ * as they will stand to bring each existing child column to its parent's, none
+ * for one already there, then the unlink of each left off its domain's type.
  */
 export declare function toAlignTypeActions(state: RootState, { relationshipId, start, end, newColumnIds }: AlignTypesInput): AnyAction[];
 /**

package/dist/utils/schema-sql/Databricks.d.ts

@@ -1,8 +1,8 @@
 import { RootState } from '../../engine/state';
 import { SchemaSQLHeader } from './options';
 import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
-export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
-export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written, logicalNameAsComment }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements, logicalNameAsComment }: FormatTableOptions): void;
 /**
  * A comment per column the diagram marks unique, after the table: UNIQUE is not
  * one of the constraints Databricks accepts, so it is reported, never dropped.

package/dist/utils/schema-sql/MSSQL.d.ts

@@ -1,7 +1,7 @@
 import { RootState } from '../../engine/state';
 import { SchemaSQLHeader } from './options';
 import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
-export declare function createSchema(state: RootState, tableIds?: readonly string[], { written }?: CreateSchemaOptions): string;
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { written, logicalNameAsComment }?: CreateSchemaOptions): string;
 export declare function formatTable(state: RootState, { buffer, table }: FormatTableOptions): void;
 /**
  * One named constraint per column the diagram marks unique, after the table.

package/dist/utils/schema-sql/MariaDB.d.ts

@@ -1,8 +1,8 @@
 import { RootState } from '../../engine/state';
 import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions } from './utils';
 export { formatDropBlock, formatHeader } from './MySQL';
-export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
-export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written, logicalNameAsComment }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements, logicalNameAsComment }: FormatTableOptions): void;
 /**
  * One named constraint per column the diagram marks unique, after the table.
  * The whole export and the per-table Schema SQL tab both write it.

package/dist/utils/schema-sql/MySQL.d.ts

@@ -1,8 +1,8 @@
 import { RootState } from '../../engine/state';
 import { SchemaSQLHeader } from './options';
 import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
-export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
-export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written, logicalNameAsComment }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements, logicalNameAsComment }: FormatTableOptions): void;
 /**
  * One named constraint per column the diagram marks unique, after the table.
  * The whole export and the per-table Schema SQL tab both write it.

package/dist/utils/schema-sql/Oracle.d.ts

@@ -1,7 +1,7 @@
 import { RootState } from '../../engine/state';
 import { SchemaSQLHeader } from './options';
 import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
-export declare function createSchema(state: RootState, tableIds?: readonly string[], { written }?: CreateSchemaOptions): string;
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { written, logicalNameAsComment }?: CreateSchemaOptions): string;
 export declare function formatTable(state: RootState, { buffer, table, written }: FormatTableOptions): void;
 /**
  * One named constraint per column the diagram marks unique, after the table.

package/dist/utils/schema-sql/PostgreSQL.d.ts

@@ -1,7 +1,7 @@
 import { RootState } from '../../engine/state';
 import { SchemaSQLHeader } from './options';
 import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
-export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written, logicalNameAsComment }?: CreateSchemaOptions): string;
 export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
 export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames, statements }: FormatIndexOptions): void;
 /**

package/dist/utils/schema-sql/SQLite.d.ts

@@ -1,12 +1,12 @@
 import { RootState } from '../../engine/state';
 import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions, WrittenObjects } from './utils';
-export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written, logicalNameAsComment }?: CreateSchemaOptions): string;
 /**
  * An integer type name, with or without a width, which an AUTOINCREMENT key
  * is written as INTEGER for; the rest keep their type and lose the keyword.
  */
 export declare function isIntegerFamily(dataType: string): boolean;
-export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+export declare function formatTable(state: RootState, { buffer, table, statements, logicalNameAsComment }: FormatTableOptions): void;
 export declare function formatIndex({ settings: { bracketType }, collections }: RootState, { buffer, index, indexNames, statements }: FormatIndexOptions): void;
 /** SQLite has no database or schema to create or select in a script. */
 export declare function formatHeader(): string;

package/dist/utils/schema-sql/Snowflake.d.ts

@@ -1,8 +1,8 @@
 import { RootState } from '../../engine/state';
 import { SchemaSQLHeader } from './options';
 import { CreateSchemaOptions, FormatIndexOptions, FormatTableOptions } from './utils';
-export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written }?: CreateSchemaOptions): string;
-export declare function formatTable(state: RootState, { buffer, table, statements }: FormatTableOptions): void;
+export declare function createSchema(state: RootState, tableIds?: readonly string[], { statements, written, logicalNameAsComment }?: CreateSchemaOptions): string;
+export declare function formatTable(state: RootState, { buffer, table, statements, logicalNameAsComment }: FormatTableOptions): void;
 export declare function formatIndex({ collections, settings: { bracketType } }: RootState, { buffer, index, indexNames }: FormatIndexOptions): void;
 /** USE SCHEMA, after CREATE SCHEMA IF NOT EXISTS for createAndUse. */
 export declare function formatHeader({ settings: { bracketType } }: RootState, header: Exclude<SchemaSQLHeader, 'none'>, name: string): string;

package/dist/utils/schema-sql/options.d.ts

@@ -19,6 +19,8 @@ export type SchemaSQLOptions = {
     statements?: SchemaSQLStatements;
     /** none when left out. */
     header?: SchemaSQLHeader;
+    /** Whether a table or column with an empty comment writes its logical name as one; off when left out. */
+    logicalNameAsComment?: boolean;
 };
 /** The name a header may write: a plain identifier, so no vendor needs it escaped. */
 export declare const HEADER_NAME_PATTERN: RegExp;

package/dist/utils/schema-sql/utils.d.ts

@@ -15,6 +15,8 @@ export interface CreateSchemaOptions {
     /** Already what the database writes (resolveSchemaSQLOptions); create when left out. */
     statements?: SchemaSQLStatements;
     written?: WrittenObjects;
+    /** Whether an empty comment writes the logical name (commentToWrite); off when left out. */
+    logicalNameAsComment?: boolean;
 }
 export interface FormatTableOptions {
     buffer: string[];
@@ -22,12 +24,16 @@ export interface FormatTableOptions {
     /** create when left out. */
     statements?: SchemaSQLStatements;
     written?: WrittenObjects;
+    /** off when left out. */
+    logicalNameAsComment?: boolean;
 }
 export interface FormatColumnOptions {
     buffer: string[];
     column: Column;
     isComma: boolean;
     spaceSize: MaxLength;
+    /** off when left out. */
+    logicalNameAsComment?: boolean;
 }
 export interface FormatRelationOptions {
     buffer: string[];
@@ -48,7 +54,15 @@ export interface FormatIndexOptions {
 export interface FormatCommentOptions {
     buffer: string[];
     table: Table;
+    /** off when left out. */
+    logicalNameAsComment?: boolean;
 }
+/**
+ * The comment the DDL writes on a table or column: its own while not blank,
+ * else its logical name while logicalNameAsComment is on and that is not
+ * blank, else the empty string, which writes no comment.
+ */
+export declare function commentToWrite({ comment, logicalName }: Pick<Table | Column, 'comment' | 'logicalName'>, logicalNameAsComment?: boolean): string;
 export interface Name {
     id: string;
     name: string;

package/dist/utils/table-clipboard/copy.d.ts

@@ -1,5 +1,4 @@
 import { RootState } from '../../engine/state';
-import { Settings } from '../../internal-types';
 import { ClipboardIndex, ClipboardPayload, ClipboardRelationship } from '.';
 export declare function tableCopyToText(state: RootState): string;
 export declare function tableCopyToHtml(state: RootState): string;
@@ -17,7 +16,7 @@ export declare function toClipboardRelationships({ doc, collections }: Pick<Root
  */
 export declare function toClipboardIndexes({ doc, collections }: Pick<RootState, 'doc' | 'collections'>, tableIds: string[]): ClipboardIndex[];
 export declare function columnsCopyToPayload({ editor: { focusTable }, collections, }: RootState): ClipboardPayload | null;
-export declare function entitiesToTsv(payload: ClipboardPayload, settings: Settings): string;
-export declare function entitiesToHtmlTable(payload: ClipboardPayload, settings: Settings): string;
+export declare function entitiesToTsv(payload: ClipboardPayload, state: RootState): string;
+export declare function entitiesToHtmlTable(payload: ClipboardPayload, state: RootState): string;
 export declare function payloadToHtml(payload: ClipboardPayload, tableHtml: string): string;
 //# sourceMappingURL=copy.d.ts.map

package/dist/utils/table-clipboard/index.d.ts

@@ -1,3 +1,4 @@
+import { RootState } from '../../engine/state';
 import { ValuesType } from '../../internal-types';
 export * from './payload';
 export * from './placement';
@@ -11,8 +12,15 @@ export declare const CellType: {
     readonly columnAutoIncrement: "columnAutoIncrement";
     readonly columnDefault: "columnDefault";
     readonly columnComment: "columnComment";
+    readonly columnLogicalName: "columnLogicalName";
+    readonly columnDomain: "columnDomain";
 };
 export type CellType = ValuesType<typeof CellType>;
 export declare const hasCellType: (value: string) => boolean;
-export declare function getShowColumnOrder(show: number, columnOrder: number[]): number[];
+/**
+ * The column types of a row's cells in their order, as the name view lays
+ * them out: the logical view's name cell holds the logical name. A column
+ * type this release does not know has no cell.
+ */
+export declare function getShowColumnOrder(show: number, columnOrder: number[], nameViewMode: RootState['settings']['nameViewMode']): number[];
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/table-clipboard/paste.d.ts

@@ -1,8 +1,8 @@
 import { RootState } from '../../engine/state';
 import { Column } from '../../internal-types';
 import { ClipboardPayload, ParseResult } from './payload';
-export declare function tablePasteFromTextToColumns({ settings: { show, columnOrder } }: RootState, text: string): Column[];
-export declare function tablePasteFromHtmlToColumns({ settings: { show, columnOrder } }: RootState, html: string): Column[];
+export declare function tablePasteFromTextToColumns(state: RootState, text: string): Column[];
+export declare function tablePasteFromHtmlToColumns(state: RootState, html: string): Column[];
 export declare function readClipboardPayload(dataTransfer: DataTransfer): ParseResult;
 export declare function payloadToColumns({ columns }: ClipboardPayload): Column[];
 //# sourceMappingURL=paste.d.ts.map

package/dist/utils/table-clipboard/payload.d.ts

@@ -10,11 +10,17 @@ export declare const PayloadKind: {
     readonly columns: "columns";
 };
 export type PayloadKind = ValuesType<typeof PayloadKind>;
+/**
+ * A copied table. Its logical name and derived flag, like a column's logical
+ * name and domain, are absent from a copy made before the dictionaries.
+ */
 export type ClipboardTable = {
     sourceId: string;
     name: string;
+    logicalName?: string;
     comment: string;
     columnIds: string[];
+    nameDerived?: boolean;
     ui: {
         x: number;
         y: number;
@@ -32,6 +38,12 @@ export type ClipboardColumn = {
     dataType: string;
     default: string;
     options: number;
+    logicalName?: string;
+    /**
+     * The domain the column linked where it was copied, which a paste keeps
+     * only while the document it lands in lists it.
+     */
+    domainId?: string;
     ui: {
         keys: number;
         widthName: number;

package/dist/utils/takeover.d.ts

@@ -0,0 +1,6 @@
+import { RootState } from '../engine/state';
+/** The overlays that take the whole canvas over, each standing a scene of its own there. */
+export declare const TAKEOVERS: ("automaticTablePlacement" | "diffViewer" | "timeTravel")[];
+/** Whether an overlay that takes the canvas over is up, which keeps Find and Replace and the Explorer shut. */
+export declare const isTakenOver: ({ editor }: RootState) => boolean;
+//# sourceMappingURL=takeover.d.ts.map

package/dist/utils/validation.d.ts

@@ -12,6 +12,7 @@ export declare const hasLanguage: (value: number) => boolean;
 export declare const hasColumnType: (value: number) => boolean;
 export declare const hasDatabaseVendor: (value: string) => boolean;
 export declare const hasCanvasType: (value: string) => boolean;
+export declare const hasNameViewMode: (value: string) => boolean;
 export declare function textInRange(width: number): number;
 export declare function toSafeString(value: any): string;
 export declare function isHighLevelTable(zoomLevel: number): boolean;

package/dist/utils/virtualRange.d.ts

@@ -0,0 +1,15 @@
+/** How many rows a virtual list draws past each edge of its view, so a short scroll finds them drawn already. */
+export declare const VIRTUAL_OVERSCAN = 8;
+/** The rows a list renders, first to last, both included; none while last is below first. */
+export type VirtualRange = {
+    first: number;
+    last: number;
+};
+/** The rows the screen shows at a scroll offset, with the overscan either side. */
+export declare function visibleRange(count: number, scrollTop: number, height: number, rowHeight: number): VirtualRange;
+/**
+ * The scroll offset nearest the one given that shows a row whole: the same
+ * while it shows, else the row's top or bottom at the edge it is past.
+ */
+export declare function offsetToShow(index: number, scrollTop: number, height: number, rowHeight: number): number;
+//# sourceMappingURL=virtualRange.d.ts.map