@dineug/erd-editor 4.1.0 → 4.2.0

package/dist/themes/tokens.d.ts

@@ -40,6 +40,10 @@ export type Theme = {
     columnSelect: string;
     columnSelectHover: string;
     columnHover: string;
+    columnHandleBackground: string;
+    columnHandleBorder: string;
+    columnHandleHoverBackground: string;
+    columnHandleHoverBorder: string;
     relationshipHover: string;
     visualizationLink: string;
     visualizationColumn: string;
@@ -81,6 +85,14 @@ export type Theme = {
     treeMatch: string;
     explorerBackground: string;
     explorerBorder: string;
+    dictionaryErrorForeground: string;
+    dictionaryErrorBackground: string;
+    dictionaryWarningForeground: string;
+    dictionaryWarningBackground: string;
+    dictionaryBackground: string;
+    dictionaryHeaderBackground: string;
+    dictionaryGridLine: string;
+    dictionaryHeaderSelect: string;
     diffInsertForeground: string;
     diffDeleteForeground: string;
     diffModifyForeground: string;

package/dist/utils/calcTable.d.ts

@@ -1,4 +1,5 @@
 import { EngineContext } from '../engine/context';
+import { FocusType } from '../engine/modules/editor/state';
 import { RootState } from '../engine/state';
 import { Table } from '../internal-types';
 import { GeometrySource } from './draw-relationship/geometrySource';
@@ -24,23 +25,38 @@ export declare function invalidateTableWidths(): void;
  * none, so only a table that shows one widens.
  */
 export declare function calcAlternateKeyWidth(table: Table, state: RootState): number;
+/**
+ * The width a document header gives the cell of a focus type: the comment at
+ * its clamp, and the logical name at its own width in the view of both names
+ * or, in the logical view, at the name's while it holds none, which that view draws.
+ */
+export declare function headerCellWidth(state: RootState, table: Table, focusType: FocusType): number;
 export declare function calcTableWidths(table: Table, state: RootState): ColumnWidth;
+/**
+ * The width of each cell a document row lays out in the view the settings
+ * show, at the widest row, 0 for a cell it leaves out. The name and the type
+ * are the cells in their places, which the logical view fills its own way.
+ */
 export type ColumnWidth = {
     width: number;
     /** The alternate key marks' room after a row's last cell, 0 while none is drawn. */
     alternateKey: number;
     name: number;
+    /** The logical name's own cell, which the view of both names alone lays out. */
+    logicalName: number;
     comment: number;
     dataType: number;
+    /** The domain's own cell, laid out while its show bit is set. */
+    domain: number;
     default: number;
     notNull: number;
     autoIncrement: number;
     unique: number;
 };
 /**
- * The width a view draws a table at: the header name, or the key badge with
- * the widest name and type among the rows given, whichever is wider. The rows
- * are the caller's to name, and the show bits and the column order are the document's, read by no view.
+ * The width a view draws a table at: the header names, or the key badge with
+ * the widest of each cell its name view lays out among the rows given, whichever is wider.
+ * The rows are the caller's to name, and no view reads the show bits or the column order.
  */
 export declare function calcViewTableWidths(table: Table, state: RootState, columnIds: string[]): ColumnWidth;
 /**
@@ -59,7 +75,7 @@ export declare function tableHeaderHeight(source?: GeometrySource): number;
 export declare function tableRowHeight(source?: GeometrySource): number;
 /** The box height for the rows given, every row of the table unless a view shows fewer. */
 export declare function calcTableHeight(table: Table, rowCount?: number, source?: GeometrySource): number;
-export declare function recalculateTableWidth({ doc: { tableIds }, collections }: RootState, { toWidth }: EngineContext): void;
+export declare function recalculateTableWidth(state: RootState, { toWidth }: EngineContext): void;
 /**
  * The box a table takes on the ERD canvas once toWidth has measured its text,
  * the size recalculateTableWidth would leave it at. It works on copies, so it

package/dist/utils/collection/domain.entity.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, Domain } from '../../internal-types';
+export declare const createDomain: (value?: DeepPartial<Domain>) => Domain;
+//# sourceMappingURL=domain.entity.d.ts.map

package/dist/utils/collection/term.entity.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, Term } from '../../internal-types';
+export declare const createTerm: (value?: DeepPartial<Term>) => Term;
+//# sourceMappingURL=term.entity.d.ts.map

package/dist/utils/collection/word.entity.d.ts

@@ -0,0 +1,3 @@
+import { DeepPartial, Word } from '../../internal-types';
+export declare const createWord: (value?: DeepPartial<Word>) => Word;
+//# sourceMappingURL=word.entity.d.ts.map

package/dist/utils/dictionary-csv/csv.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reads CSV text as RFC 4180 writes it: a quoted field holds commas, line
+ * breaks and doubled quotes. A record ends at CRLF, LF or CR, a blank line is
+ * no record, and a stray quote stays as text, so no input throws.
+ */
+export declare function parseCsv(text: string): string[][];
+/**
+ * Writes records as CSV text a spreadsheet opens as UTF-8: a byte order mark
+ * first and CRLF after every record. Only a field holding a quote, a comma or
+ * a line break is quoted, its quotes doubled.
+ */
+export declare function serializeCsv(records: ReadonlyArray<ReadonlyArray<string>>): string;
+//# sourceMappingURL=csv.d.ts.map

package/dist/utils/dictionary-csv/decode.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reads a file's bytes as UTF-8 with its byte order mark dropped, or as EUC-KR
+ * when they are no valid UTF-8, as an older public-standard file is. Bytes
+ * neither reads come out as replacement characters, which no header matches.
+ */
+export declare function decodeCsvBytes(bytes: ArrayBuffer | Uint8Array): string;
+//# sourceMappingURL=decode.d.ts.map

package/dist/utils/dictionary-csv/dictionaryCsv.d.ts

@@ -0,0 +1,55 @@
+import { DictionaryKind } from '../../engine/modules/dictionary/actions';
+import { Domain, Term, ValuesType, Word } from '../../internal-types';
+/** The two layouts a dictionary file comes in: the editor's own and the public standard's. */
+export declare const DictionaryCsvFormat: {
+    readonly own: "own";
+    readonly publicStandard: "publicStandard";
+};
+export type DictionaryCsvFormat = ValuesType<typeof DictionaryCsvFormat>;
+/** What a file's row of each dictionary holds; a term names its domain by the domain's name. */
+export type DictionaryCsvValues = {
+    [DictionaryKind.word]: Omit<Word, 'id' | 'order'>;
+    [DictionaryKind.term]: Omit<Term, 'id' | 'domainId' | 'order'> & {
+        domain: string;
+    };
+    [DictionaryKind.domain]: Omit<Domain, 'id' | 'order'>;
+};
+export type DictionaryCsvField<K extends DictionaryKind> = Extract<keyof DictionaryCsvValues[K], string>;
+/**
+ * The columns of the editor's own format, in the order an export writes them,
+ * each headed by its field's name. No id rides, since every document mints its
+ * own, so a file carries into another document whole.
+ */
+export declare const DictionaryCsvColumns: {
+    readonly [K in DictionaryKind]: ReadonlyArray<DictionaryCsvField<K>>;
+};
+/** A row a file brings: its name, and each other field the file has a column for. */
+export type DictionaryCsvRow<K extends DictionaryKind> = {
+    name: string;
+} & Partial<DictionaryCsvValues[K]>;
+/** A dictionary file as read: its kind and format, told by its header, and its rows in file order. */
+export type DictionaryCsvRead = {
+    [K in DictionaryKind]: {
+        kind: K;
+        format: DictionaryCsvFormat;
+        /** The fields the file has columns for, the name first, in the own format's order. */
+        fields: Array<DictionaryCsvField<K>>;
+        /** Every row with a name, each holding exactly the fields above. */
+        rows: Array<DictionaryCsvRow<K>>;
+        /** The rows left out for an empty name; a record of empty cells is no row at all. */
+        skipped: number;
+    };
+}[DictionaryKind];
+/**
+ * Reads a dictionary file's text by the one layout its header names, else null.
+ * The own format's cells stay as written, so an export reads back to its rows;
+ * the public standard's are trimmed, and a domain's type columns join in one.
+ */
+export declare function readDictionaryCsv(text: string): DictionaryCsvRead | null;
+/**
+ * Writes one dictionary's rows in the editor's own format: the field names as
+ * the header over one record per row, in the order given. A term's row names
+ * its domain, which the caller looks up by the term's domain id.
+ */
+export declare function writeDictionaryCsv<K extends DictionaryKind>(kind: K, rows: ReadonlyArray<DictionaryCsvValues[K]>): string;
+//# sourceMappingURL=dictionaryCsv.d.ts.map

package/dist/utils/dictionary-csv/index.d.ts

@@ -0,0 +1,4 @@
+export * from './csv';
+export * from './decode';
+export * from './dictionaryCsv';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/diff/types.d.ts

@@ -59,6 +59,10 @@ export type DiffEntry = {
     name: string;
     /** What the saved document calls it, the same as name unless renamed or added. */
     prevName: string;
+    /** A table's or column's logical name, as name is taken, which a label shows and no change counts; '' for any other. */
+    logicalName: string;
+    /** The saved document's logical name, as prevName is taken. */
+    prevLogicalName: string;
     changes: DiffChange[];
     /** A table's columns, indexes and foreign keys, in that order. */
     children: DiffEntry[];

package/dist/utils/file/exportFile.d.ts

@@ -1,3 +1,4 @@
+import { DictionaryKind } from '../../engine/modules/dictionary/actions';
 import { DocumentPngOptions, DocumentSvgOptions } from '../../services/export-png';
 type ExportOptions = {
     fileName: string;
@@ -6,6 +7,15 @@ type ExportFileCallback = (blob: Blob, options: ExportOptions) => void;
 export declare function setExportFileCallback(callback: ExportFileCallback | null): void;
 export declare function exportJSON(json: string, name?: string): void;
 export declare function exportSchemaSQL(sql: string, name?: string): void;
+/**
+ * One dictionary's sheet as a CSV file, named as the other exports are with
+ * the sheet after the time. The text is written as given, so the byte order
+ * mark and the CRLF line ends the dictionary codec writes reach the file.
+ *
+ * @example
+ * exportCSV(writeDictionaryCsv('word', words), 'word', databaseName);
+ */
+export declare function exportCSV(csv: string, sheet: DictionaryKind, name?: string): void;
 /** The Code Generator's text, named as the other exports are, with its language's extension. */
 export declare function exportCode(code: string, extension: string, name?: string): void;
 /**

package/dist/utils/find-replace/findMatches.d.ts

@@ -10,13 +10,14 @@ export declare const FindField: {
     readonly memo: "memo";
     readonly indexName: "indexName";
     readonly tableGroupName: "tableGroupName";
+    readonly logicalName: "logicalName";
 };
 export type FindField = ValuesType<typeof FindField>;
 export declare const FindFieldList: ReadonlyArray<FindField>;
 /**
  * The kinds of text Find and Replace first opens on, the names alone of
- * tables, columns, indexes and table groups (an owner decision): a comment or
- * memo is prose a rename should not reach unasked. No fields reads every kind.
+ * tables, columns, indexes and table groups and the logical names (owner
+ * decisions): a comment or memo is prose a rename should not reach unasked.
  */
 export declare const DEFAULT_FIND_FIELDS: ReadonlyArray<FindField>;
 export type FindMatch = {
@@ -32,6 +33,11 @@ export type FindMatch = {
     end: number;
 };
 type Field = Omit<FindMatch, 'start' | 'end'>;
+/**
+ * Whether a logical name field is a table's, which bears its table's id as
+ * its own, rather than a column's: the one field kind both of them hold.
+ */
+export declare const isTableLogicalName: ({ field, id, tableId, }: Pick<FindMatch, "field" | "id" | "tableId">) => boolean;
 /**
  * What changes a text the search reads, or which fields it walks: the actions
  * a search on screen runs again on. A hover, a selection or a scroll changes
@@ -50,8 +56,8 @@ export type FieldOrder = {
 /** The tables and the table groups by name, as the tree lists them, ties in document order. */
 export declare function treeOrderOf({ doc, collections }: RootState): FieldOrder;
 /**
- * Every text field the fields given cover: each table's name and comment,
- * its columns' names and comments and its index names, then the table groups'
+ * Every text field the fields given cover: each table's logical name, name
+ * and comment, its columns' alike and its index names, then the table groups'
  * names and the memos, in document order or in the order given.
  */
 export declare function walkFields(state: RootState, fields: ReadonlyArray<FindField>, order?: FieldOrder): Field[];

package/dist/utils/find-replace/present.d.ts

@@ -8,7 +8,7 @@ export declare const FindFieldLabel: Record<FindField, PlainMessageKey>;
  * table and column, the table an index belongs to, and nothing for a memo or
  * a table group, which stand on their own.
  */
-export declare function locationOf({ collections }: RootState, { field, id, tableId }: FindMatch, i18n?: Pick<I18n, 't'>): string;
+export declare function locationOf({ collections }: RootState, match: FindMatch, i18n?: Pick<I18n, 't'>): string;
 /** A result row's second line: where the match sits, then the kind of text it was found in. */
 export declare function describeMatch(state: RootState, match: FindMatch, i18n?: Pick<I18n, 't'>): string;
 export type Snippet = {

package/dist/utils/find-replace/replaceActions.d.ts

@@ -1,15 +1,19 @@
-import { AnyAction } from '@dineug/r-html';
+import { CompositionAction } from '@dineug/r-html';
 import { FindMatch } from './findMatches';
 import { Matcher } from './matcher';
-/** The atom action that writes a new value into the field a match was found in. */
-export declare function toFieldAction({ field, id, tableId }: Pick<FindMatch, 'field' | 'id' | 'tableId'>, value: string): AnyAction;
+/**
+ * What writes a new value into the field a match was found in, as an edit by
+ * hand does: a name through the generator that turns its derived flag off, a
+ * logical name through the one that derives its name, the rest by atom action.
+ */
+export declare function toFieldAction(match: Pick<FindMatch, 'field' | 'id' | 'tableId'>, value: string): CompositionAction;
 export type ReplaceActions = {
-    actions: AnyAction[];
+    actions: CompositionAction[];
     /** The matches the replacement changed, leaving out one it wrote back as it was. */
     replaced: number;
 };
 /**
- * One atom action per field whose text the replacement changes, for a single
+ * One field action per field whose text the replacement changes, for a single
  * dispatch: one undo entry, and the same LWW writes a peer receives from an
  * edit by hand. Given one match, only that occurrence is replaced.
  *

package/dist/utils/focus.d.ts

@@ -1,6 +1,8 @@
 import { FocusTable, FocusType, SharedFocus } from '../engine/modules/editor/state';
 export declare function isFocus(focusTable: Pick<FocusTable, 'tableId' | 'columnId' | 'focusType'> | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
 export declare const isSelectColumn: (focusTable: FocusTable | null, tableId: string, columnId: string) => boolean;
+/** Whether the focus stands on any cell of this column. */
+export declare const isFocusColumn: (focusTable: Pick<FocusTable, "tableId" | "columnId"> | null, tableId: string, columnId: string) => boolean;
 export declare function isEdit(focusTable: FocusTable | null, focusType: FocusType, tableId: string, columnId?: string | null): boolean;
 export declare function lastCursorFocus(input: HTMLInputElement | HTMLTextAreaElement): void;
 export declare const toSharedFocus: (focusTable: FocusTable | null) => SharedFocus | null;

package/dist/utils/formatCount.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A count shown beside a name, a Dictionary sheet's or an Explorer folder's, its
+ * thousands grouped as the language groups them, in the digits 0 to 9 every
+ * other number in the editor is written in.
+ *
+ * @example
+ * formatCount('de-DE', 13176); // '13.176'
+ */
+export declare function formatCount(locale: string, count: number): string;
+//# sourceMappingURL=formatCount.d.ts.map

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

@@ -37,7 +37,7 @@ 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" | "addTableGroup" | "findReplace" | "groupSelectedTables" | "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.

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/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;