@dineug/erd-editor 3.10.0 → 4.0.0

package/dist/components/schema-sql/schema-sql-options/SchemaSQLOptions.d.ts

@@ -0,0 +1,24 @@
+import { FC } from '@dineug/r-html';
+/** The panel's id, which the button folding it away controls. */
+export declare const SCHEMA_SQL_OPTIONS_ID = "schema-sql-options";
+/** Space is the hand tool's key, whose binding cancels the keydown and with it a native button's press. */
+export declare const keepSpace: (event: KeyboardEvent) => void;
+export type SchemaSQLOptionsProps = {
+    isDarkMode: boolean;
+    readonly: boolean;
+    /** The tables a drop and re-create names, in the order the DDL writes them. */
+    tables: ReadonlyArray<string>;
+    /** The Oracle names over 30 bytes, which 12.2 was the first to take. */
+    longNames: ReadonlyArray<string>;
+    onHide: () => void;
+    onSave: () => void;
+    onCopy: () => void;
+};
+/**
+ * The options beside the Schema SQL: the database and the bracket, then this
+ * window's statements, header and tables, then the scripts the document
+ * saves, and the buttons that save and copy the text.
+ */
+declare const SchemaSQLOptions: FC<SchemaSQLOptionsProps>;
+export default SchemaSQLOptions;
+//# sourceMappingURL=SchemaSQLOptions.d.ts.map

package/dist/components/schema-sql/schema-sql-options/SchemaSQLOptions.styles.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The options beside the code, a fixed width whatever the editor's, its rule
+ * on the left, where the code stands in every language.
+ */
+export declare const panel: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const head: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const title: import('@dineug/r-html').CSSTemplateLiterals;
+/** The part that scrolls, between the title and the buttons. */
+export declare const body: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const group: import('@dineug/r-html').CSSTemplateLiterals;
+/** A group under a rule, drawn halfway into the gap above it. */
+export declare const separated: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const row: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const column: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const caption: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const note: import('@dineug/r-html').CSSTemplateLiterals;
+/** A list beside its name, as wide whatever the database or the bracket. */
+export declare const select: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const segments: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const segment: import('@dineug/r-html').CSSTemplateLiterals;
+/** The Tables list: All, each table group, then No group. */
+export declare const choices: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * A box and its name on one line, the whole line taking the press; the box
+ * in the accent colour once checked, a dash while All is mixed.
+ */
+export declare const choice: import('@dineug/r-html').CSSTemplateLiterals;
+/** A table group's color, ringed so a pale one shows on the panel. */
+export declare const dot: import('@dineug/r-html').CSSTemplateLiterals;
+/** A name cut to one line; a group without one reads unnamed, dimmed. */
+export declare const choiceName: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * What a drop and re-create takes with it, in the panel's own warning colours,
+ * a long table name broken to stay inside the box.
+ */
+export declare const warning: import('@dineug/r-html').CSSTemplateLiterals;
+/** One line of the text tall, so the icon stands beside the first. */
+export declare const warningIcon: import('@dineug/r-html').CSSTemplateLiterals;
+/** The buttons under the scrolling part, always in sight. */
+export declare const foot: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const actions: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const action: import('@dineug/r-html').CSSTemplateLiterals;
+/** A square icon button: the panel's Hide and the code's Show. */
+export declare const icon: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=SchemaSQLOptions.styles.d.ts.map

package/dist/components/schema-sql/schema-sql-options/ScriptEditor.d.ts

@@ -0,0 +1,20 @@
+import { FC } from '@dineug/r-html';
+export type ScriptEditorProps = {
+    /** What the label beside it points its for at. */
+    id: string;
+    /** The script the document holds. */
+    value: string;
+    placeholder: string;
+    theme: 'dark' | 'light';
+    readonly: boolean;
+    /** Called once per edit, as the field loses the focus, with the text it holds. */
+    onCommit: (value: string) => void;
+};
+/**
+ * A text field over its own highlighted text, left to right in any language as
+ * the code block is, which commits what was typed as it loses the focus: one
+ * action per edit. A change of the script while focused shows once it is left untyped.
+ */
+declare const ScriptEditor: FC<ScriptEditorProps>;
+export default ScriptEditor;
+//# sourceMappingURL=ScriptEditor.d.ts.map

package/dist/components/schema-sql/schema-sql-options/ScriptEditor.styles.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The box both layers fill, its background the highlight's, set inline, and a
+ * stacking context of its own, so the raised field stays under the overlays.
+ */
+export declare const editor: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * The field a reader types into, in flow and as tall as its text, raised over
+ * the preview, which an absolute box would otherwise paint above it.
+ */
+export declare const input: import('@dineug/r-html').CSSTemplateLiterals;
+/** The highlighted text under the field, stretched onto it. */
+export declare const preview: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=ScriptEditor.styles.d.ts.map

package/dist/components/schema-sql/schema-sql-options/dropWarning.d.ts

@@ -0,0 +1,8 @@
+import { I18n } from '../../../i18n/translate';
+/**
+ * What a drop and re-create takes with it, the tables named in the reader's
+ * language, the first four and a count past five; Snowflake replaces them in
+ * place. Null with no table to drop.
+ */
+export declare function formatDropWarning(i18n: Pick<I18n, 'locale' | 'dir' | 't'>, database: number, tables: ReadonlyArray<string>): string | null;
+//# sourceMappingURL=dropWarning.d.ts.map

package/dist/components/schema-sql/schemaSQLView.d.ts

@@ -0,0 +1,71 @@
+import { AppContext } from '../appContext';
+import { RootState } from '../../engine/state';
+import { SchemaSQLHeader, SchemaSQLStatements } from '../../utils/schema-sql';
+/** Whether an options panel shows: unset until the editor is first measured. */
+export type OptionsPanelState = 'unset' | 'open' | 'closed';
+/** Where a tab keeps its options panel's place, the Code Generator's as this one's. */
+export type PanelView = {
+    panel: OptionsPanelState;
+};
+/** Which tables the DDL writes, by the table group they are in. */
+export type SchemaSQLTableChoice = {
+    /** Each table group checked or not, by id. */
+    groups: Readonly<Record<string, boolean>>;
+    /** Whether the tables in no group are checked. */
+    noGroup: boolean;
+};
+export type SchemaSQLView = {
+    /** The statements asked for, which each database resolves to what it has. */
+    statements: SchemaSQLStatements;
+    /** The header asked for, resolved the same way. */
+    header: SchemaSQLHeader;
+    /** Replaced whole, never changed in place, so a watcher hears one change. */
+    tables: SchemaSQLTableChoice;
+    panel: OptionsPanelState;
+    /** Set by the export path, spent by the panel on the Save file button. */
+    focusSave: boolean;
+};
+/**
+ * The window's own Schema SQL choices: never in the store, the file or a
+ * change event, kept until the element goes, one set per editor.
+ */
+export declare function schemaSQLViewOf({ store, }: Pick<AppContext, 'store'>): SchemaSQLView;
+/**
+ * Whether the panel shows: an unset panel opens on an editor 640px wide or
+ * more, once it is measured, and keeps that whatever the width does next.
+ */
+export declare function resolvePanel(view: PanelView, editorWidth: number): 'open' | 'closed' | 'unknown';
+/** Folds a panel away or opens it; one not measured yet opens. */
+export declare function togglePanel(view: PanelView, editorWidth: number): void;
+/** Folds the Schema SQL panel away or opens it. */
+export declare function toggleSchemaSQLPanel(app: Pick<AppContext, 'store'>): void;
+/** The Schema SQL tab with its panel open and Save file focused, which saves nothing yet. */
+export declare function showSchemaSQLExport(app: Pick<AppContext, 'store'>): void;
+/** Whether every group the choice holds and the tables in none are checked. */
+export declare function isEveryTableChosen({ groups, noGroup }: SchemaSQLTableChoice): boolean;
+/**
+ * The choice over the groups the document lists, in its order: a group it has
+ * not met starts checked only while every box was, and one no longer listed
+ * is dropped; with no group listed, every box is checked again.
+ */
+export declare function resolveTableChoice(choice: SchemaSQLTableChoice, groupIds: ReadonlyArray<string>): SchemaSQLTableChoice;
+/**
+ * Matches the choice to the document's groups as they change, so a group added
+ * later starts as every box was then; it writes only a choice that moved.
+ */
+export declare function syncTableChoice(view: SchemaSQLView, groupIds: ReadonlyArray<string>): void;
+/** Checks or unchecks every box. */
+export declare function chooseAllTables(view: SchemaSQLView, groupIds: ReadonlyArray<string>, checked: boolean): void;
+/** Checks or unchecks one group, every other box as it reads. */
+export declare function chooseTableGroup(view: SchemaSQLView, groupIds: ReadonlyArray<string>, groupId: string, checked: boolean): void;
+/** Checks or unchecks the tables in no group, every other box as it reads. */
+export declare function chooseNoGroup(view: SchemaSQLView, groupIds: ReadonlyArray<string>, checked: boolean): void;
+/** Whether no box is checked while the document has a group, which writes nothing. */
+export declare function isNoTableChosen(choice: SchemaSQLTableChoice, groupIds: ReadonlyArray<string>): boolean;
+/**
+ * The ids of the tables the checked boxes hold, in document order, or
+ * undefined for the whole document, while every box is checked or the
+ * document has no group; a table's group reads as getTableGroupId reads it.
+ */
+export declare function chosenTableIds(state: RootState, choice: SchemaSQLTableChoice): string[] | undefined;
+//# sourceMappingURL=schemaSQLView.d.ts.map

package/dist/components/settings/Settings.styles.d.ts

@@ -5,6 +5,13 @@ export declare const content: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const section: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const row: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const vertical: (size: number) => import('@dineug/r-html').CSSTemplateLiterals;
+export declare const lockSection: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const lockList: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const lockRow: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const lockName: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const lockControl: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const lockValue: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const lockButton: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const columnOrderSection: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const columnOrderList: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const columnOrderItem: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/components/settings/columnTypeLabels.d.ts

@@ -0,0 +1,8 @@
+import { PlainMessageKey } from '../../i18n/translate';
+/**
+ * The name the column order list gives each column type, as the key of its
+ * message: kept beside the list, out of the schema constants the peer entry
+ * reaches, so no editor text travels with the peer.
+ */
+export declare const ColumnTypeToMessageKey: Readonly<Record<number, PlainMessageKey>>;
+//# sourceMappingURL=columnTypeLabels.d.ts.map

package/dist/components/settings/lockSettingRows.d.ts

@@ -0,0 +1,16 @@
+import { RootState } from '../../engine/state';
+import { I18n, PlainMessageKey } from '../../i18n/translate';
+type LockedValues = RootState['settings']['lockedValues'];
+type Translator = Pick<I18n, 't'>;
+export type LockSettingRow = {
+    nameKey: PlainMessageKey;
+    lockSettingType: number;
+    toText: (values: LockedValues, i18n: Translator) => string;
+};
+/**
+ * The Settings tab's lock rows, one per lock, each naming the value it holds
+ * by the name the menu that sets it gives, in the reader's language.
+ */
+export declare const lockSettingRows: ReadonlyArray<LockSettingRow>;
+export {};
+//# sourceMappingURL=lockSettingRows.d.ts.map

package/dist/components/settings/settings-lnb/SettingsLnb.d.ts

@@ -1,10 +1,13 @@
 import { FC } from '@dineug/r-html';
+import { PlainMessageKey } from '../../../i18n/translate';
 import { ValuesType } from '../../../internal-types';
 export declare const Lnb: {
     readonly preferences: "Preferences";
     readonly shortcuts: "Shortcuts";
 };
 export type Lnb = ValuesType<typeof Lnb>;
+/** Each page's name as the key of its message; the page ids stay English. */
+export declare const LnbLabelKey: Readonly<Record<Lnb, PlainMessageKey>>;
 export type SettingsLnbProps = {
     value: Lnb;
     onChange: (value: Lnb) => void;

package/dist/components/settings/settingsPage.d.ts

@@ -0,0 +1,10 @@
+import { Lnb } from './settings-lnb/SettingsLnb';
+import { RxStore } from '../../engine/rx-store';
+/**
+ * Takes the reader to a page of the Settings tab from outside it, the welcome
+ * screen's Shortcuts row say: the tab opens, and reads the page as it mounts.
+ */
+export declare function requestSettingsPage(store: RxStore, page: Lnb): void;
+/** The page asked for since the Settings tab last mounted, handed out once. */
+export declare function takeSettingsPage(store: RxStore): Lnb | undefined;
+//# sourceMappingURL=settingsPage.d.ts.map

package/dist/components/theme-builder/ThemeBuilder.d.ts

@@ -1,8 +1,16 @@
 import { FC } from '@dineug/r-html';
-import { ThemeOptions } from '../../themes/radix-ui-theme';
+import { IconName } from '../primitives/icon/icons';
+import { PlainMessageKey } from '../../i18n/translate';
+import { AppearanceOption, ThemeOptions } from '../../themes/radix-ui-theme';
 export type ThemeBuilderProps = {
     theme: ThemeOptions;
 };
+/** The three appearances in the order the builder's buttons and the palette's Theme rows list them. */
+export declare const APPEARANCE_BUTTONS: ReadonlyArray<{
+    appearance: AppearanceOption;
+    icon: IconName;
+    labelKey: PlainMessageKey;
+}>;
 declare const ThemeBuilder: FC<ThemeBuilderProps>;
 export default ThemeBuilder;
 //# sourceMappingURL=ThemeBuilder.d.ts.map

package/dist/components/theme-builder/ThemeBuilder.styles.d.ts

@@ -1,14 +1,17 @@
 /**
- * A panel placed over whichever tab is up. The tab wrapper raises no stacking
- * context of its own, so a raised descendant inside it would paint over an
- * unraised sibling; the same step, later in the root, keeps this panel on top.
+ * A panel placed over whichever tab is up, padded as Find and Replace is. The
+ * tab wrapper raises no stacking context, so a raised descendant would paint
+ * over an unraised sibling; the same step later in the root keeps this on top.
  */
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const header: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const title: import('@dineug/r-html').CSSTemplateLiterals;
+/** A 26px square tool tinted under the pointer, as the editor's other panels close. */
+export declare const close: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const subTitle: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const palette: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const color: import('@dineug/r-html').CSSTemplateLiterals;
-export declare const lightDarkButtonGroup: import('@dineug/r-html').CSSTemplateLiterals;
-export declare const lightDarkButton: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const appearanceButtonGroup: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const appearanceButton: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const vertical: import('@dineug/r-html').CSSTemplateLiterals;
 //# sourceMappingURL=ThemeBuilder.styles.d.ts.map

package/dist/components/toast-container/openStatusToast.d.ts

@@ -0,0 +1,29 @@
+import { DOMTemplateLiterals } from '@dineug/r-html';
+import { ToastTone } from '../primitives/toast/Toast';
+import { Emitter } from '../../utils/emitter';
+export type StatusToast = {
+    /** Names the report and the values it shows, so only the same one replaces it. */
+    key: string;
+    title: DOMTemplateLiterals;
+    description?: DOMTemplateLiterals;
+    tone?: ToastTone;
+    close?: Promise<void>;
+};
+/**
+ * Reports how something ended: its one line as the title, a second line as the
+ * description, and a tone's mark when it was done or not done. Opened again
+ * under its key, it takes the place of the one still up rather than piling on.
+ *
+ * @example
+ * openStatusToast(emitter, { key: 'common.toast.noTablesToPlace', title: localized('common.toast.noTablesToPlace') });
+ */
+export declare function openStatusToast(emitter: Emitter, { key, title, description, tone, close }: StatusToast): void;
+/**
+ * Says whether text reached the clipboard, a refusal as plainly as a copy, under
+ * one key so a press repeated shows one toast.
+ *
+ * @example
+ * reportCopy(emitter, copyToClipboard(state.sql));
+ */
+export declare function reportCopy(emitter: Emitter, copying: Promise<unknown>): Promise<void>;
+//# sourceMappingURL=openStatusToast.d.ts.map

package/dist/components/toast-container/openToastWhileRunning.d.ts

@@ -6,7 +6,7 @@ import { Emitter } from '../../utils/emitter';
  * a caller report the outcome after this toast rather than on top of it.
  *
  * @example
- * await openToastWhileRunning(emitter, running, html`<${Toast} description=${'Working'} />`);
+ * await openToastWhileRunning(emitter, running, html`<${Toast} busy=${true} title=${localized('exportImage.copying')} />`);
  */
 export declare function openToastWhileRunning(emitter: Emitter, running: Promise<unknown>, message: DOMTemplateLiterals): Promise<void>;
 //# sourceMappingURL=openToastWhileRunning.d.ts.map

package/dist/components/toolbar/Toolbar.d.ts

@@ -1,6 +1,7 @@
 import { FC } from '@dineug/r-html';
 export type ToolbarProps = {
     enableThemeBuilder: boolean;
+    enableLocalePicker?: boolean;
     readonly: boolean;
 };
 declare const Toolbar: FC<ToolbarProps>;

package/dist/components/visualization/graph-node/GraphNode.d.ts

@@ -16,8 +16,8 @@ export type GraphNodeProps = {
 };
 /**
  * One dot, owning its own hover and drag. A hovered table opens its preview
- * and lights its neighbourhood, a hovered column only wears a ring, and a
- * press pins the node under the pointer and reheats the layout around it.
+ * and lights its neighbourhood, a hovered column only wears a ring, a main
+ * press pins the node and reheats the layout, and a middle one pans the view.
  */
 declare const GraphNode: FC<GraphNodeProps>;
 export default GraphNode;

package/dist/components/visualization/graphPan.d.ts

@@ -0,0 +1,12 @@
+import { KonvaEventObject } from 'konva/lib/Node';
+import { VisualizationState } from './visualizationView';
+/**
+ * Pans the graph view with the pointer, in stage px, from a press on the
+ * background or a middle press anywhere. A pan is a drag too: a dot the pointer
+ * crosses on the way would otherwise open its preview under a busy hand.
+ *
+ * @example
+ * on:mousedown={(event) => captureGraphPan(event, state)}
+ */
+export declare function captureGraphPan(event: KonvaEventObject<Event>, state: VisualizationState): void;
+//# sourceMappingURL=graphPan.d.ts.map

package/dist/components/visualization/visualizationView.d.ts

@@ -13,8 +13,8 @@ export declare const NAME_MAX_LENGTH = 15;
  * truncateName('a_very_long_table_name'); // 'a_very_long_tab…'
  */
 export declare function truncateName(name: string): string;
-/** The text a table's label draws: its name cut to length, or a placeholder. */
-export declare function labelOf(node: Pick<VisualizationNode, 'name'>): string;
+/** The text a table's label draws: its name cut to length, or the placeholder its input shows. */
+export declare function labelOf(node: Pick<VisualizationNode, 'name'>, placeholder: string): string;
 /** Whether a table has a name of its own, which is what its label is painted by. */
 export declare const hasName: (node: Pick<VisualizationNode, "name">) => boolean;
 export declare const TABLE_RADIUS = 8;

package/dist/constants/language.d.ts

@@ -3,6 +3,6 @@
  * the annotation used to widen them to — CodeBlock's lang is a union, and
  * widening here meant nothing checked that these were members of it.
  */
-export type Lang = 'csharp' | 'go' | 'graphql' | 'java' | 'kotlin' | 'python' | 'scala' | 'sql' | 'typescript';
+export type Lang = 'csharp' | 'go' | 'graphql' | 'java' | 'json' | 'kotlin' | 'mermaid' | 'php' | 'python' | 'rust' | 'scala' | 'sql' | 'swift' | 'typescript';
 export declare const LanguageToLangMap: Record<number, Lang>;
 //# sourceMappingURL=language.d.ts.map

package/dist/constants/layout.d.ts

@@ -1,6 +1,15 @@
 export declare const START_X = 200;
 export declare const START_Y = 100;
 export declare const START_ADD = 50;
+/** The corner the grid an import lands in starts at, on both axes. */
+export declare const TABLE_SORT_START = 50;
+/** The room the grid an import lands in keeps right of and below each table. */
+export declare const TABLE_SORT_MARGIN = 80;
+/**
+ * How far below the diagram the block an append brings starts, the gap the
+ * grid an import lands in keeps between its rows.
+ */
+export declare const APPEND_GAP = 80;
 export declare const DUPLICATE_MIN_MOVE = 4;
 /**
  * How far, in screen px, a press on a cell that also takes a click travels
@@ -101,9 +110,30 @@ export declare const MEMO_PADDING = 8;
 export declare const MEMO_HEADER_HEIGHT: number;
 export declare const MEMO_MIN_WIDTH: number;
 export declare const MEMO_MIN_HEIGHT = 100;
+/**
+ * The room a table group's box keeps around each member table on every side,
+ * and around the tables a group is made from.
+ */
+export declare const TABLE_GROUP_PADDING = 24;
+/**
+ * The bar a table group's name is drawn on along the top of its box, as tall
+ * as a table's header band, which the box's top padding clears as well.
+ */
+export declare const TABLE_GROUP_TITLE_HEIGHT = 28;
+/**
+ * The least a sash resizes a group to, which its members' padded box raises
+ * further: wide enough for a short name, tall enough for a body under the bar.
+ */
+export declare const TABLE_GROUP_MIN_WIDTH = 160;
+export declare const TABLE_GROUP_MIN_HEIGHT: number;
+/** The group a click of the draw mode makes, without a drag: room for two tables side by side. */
+export declare const TABLE_GROUP_DEFAULT_WIDTH = 480;
+export declare const TABLE_GROUP_DEFAULT_HEIGHT = 320;
 export declare const MINIMAP_SIZE = 150;
 export declare const MINIMAP_MARGIN = 20;
 export declare const TOOLBAR_HEIGHT = 30;
+/** The width of the toolbar's database name, which every language's placeholder fits. */
+export declare const TOOLBAR_DATABASE_NAME_WIDTH = 150;
 /**
  * The padding around the Table Properties body. A band stuck to an edge of the
  * body reaches back over it, so no row scrolls into sight behind the band.
@@ -112,6 +142,10 @@ export declare const TABLE_PROPERTIES_BODY_PADDING = 12;
 /** How many rows the Table Properties index order shows before it scrolls the rest. */
 export declare const INDEX_ORDER_MAX_ROWS = 3;
 export declare const DIFF_TREE_WIDTH = 200;
+/** The width of the options panel beside the code, on the Schema SQL and Code Generator tabs. */
+export declare const SCHEMA_SQL_PANEL_WIDTH = 300;
+/** An editor narrower than this opens the Schema SQL and Code Generator tabs with their panels folded away. */
+export declare const SCHEMA_SQL_PANEL_COLLAPSE_BELOW = 640;
 /**
  * How thick a relationship connector is drawn. A whole number rather than a
  * fraction, so the stroke lands on pixel boundaries instead of spreading across

package/dist/constants/open.d.ts

@@ -4,9 +4,12 @@ export declare const Open: {
     readonly tableProperties: "tableProperties";
     readonly search: "search";
     readonly themeBuilder: "themeBuilder";
+    readonly localePicker: "localePicker";
     readonly diffViewer: "diffViewer";
     readonly timeTravel: "timeTravel";
     readonly findReplace: "findReplace";
+    readonly exportImage: "exportImage";
+    readonly mapColumns: "mapColumns";
 };
 export type Open = ValuesType<typeof Open>;
 //# sourceMappingURL=open.d.ts.map

package/dist/constants/schema.d.ts

@@ -1,3 +1,4 @@
+import { ValuesType } from '../internal-types';
 export declare const CanvasType: {
     readonly ERD: "ERD";
     readonly visualization: "@dineug/erd-editor/builtin-visualization";
@@ -18,6 +19,8 @@ export declare const Show: {
     readonly relationship: 256;
     readonly columnAlternateKey: 512;
     readonly hideReferentialAction: 1024;
+    readonly hideTableGroup: 2048;
+    readonly hideMemo: 4096;
 };
 export declare const ColumnType: {
     readonly columnName: 1;
@@ -55,6 +58,14 @@ export declare const Language: {
     readonly Drizzle: 2048;
     readonly DBML: 4096;
     readonly AML: 8192;
+    readonly Mermaid: 16384;
+    readonly PHP: 32768;
+    readonly Doctrine: 65536;
+    readonly Rust: 131072;
+    readonly SeaORM: 262144;
+    readonly Swift: 524288;
+    readonly Zod: 1048576;
+    readonly JSONSchema: 2097152;
 };
 export declare const LanguageList: readonly number[];
 export declare const NameCase: {
@@ -114,16 +125,26 @@ export declare const OrderType: {
     readonly DESC: 2;
 };
 export declare const OrderTypeList: readonly number[];
-export declare const SaveSettingType: {
-    readonly scroll: 1;
-    readonly zoomLevel: 2;
+export declare const LockSettingType: {
+    readonly viewport: 1;
+    readonly canvasType: 2;
+    readonly language: 4;
+    readonly tableNameCase: 8;
+    readonly columnNameCase: 16;
+    readonly bracketType: 32;
 };
+export declare const LockSettingTypeList: readonly number[];
+export declare const LockSettingFields: Readonly<Record<number, readonly ("zoomLevel" | "canvasType" | "language" | "bracketType" | "originX" | "originY" | "tableNameCase" | "columnNameCase")[]>>;
 export declare const CANVAS_SIZE_MAX: 20000;
 export declare const CANVAS_SIZE_MIN: 2000;
 export declare const CANVAS_ZOOM_MAX: 1.5;
 export declare const CANVAS_ZOOM_MIN: 0.1;
+export declare const DDLScriptPosition: {
+    readonly before: "before";
+    readonly after: "after";
+};
+export declare const DDLScriptPositionList: ReadonlyArray<ValuesType<typeof DDLScriptPosition>>;
 export declare const BracketTypeMap: Record<number, string>;
 /** The clause each action writes after ON DELETE / ON UPDATE; none writes none. */
 export declare const ReferentialActionToSQL: Record<number, string>;
-export declare const ColumnTypeToName: Record<number, string>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/constants/sql/dataType/PostgreSQL.d.ts

@@ -1,6 +1,7 @@
 import { DataTypeHint } from '.';
 /**
- * https://www.postgresql.org/docs/current/datatype.html
+ * https://www.postgresql.org/docs/current/datatype.html, and dec, which the
+ * grammar reads as numeric, as it reads decimal.
  */
 export declare const PostgreSQLTypes: DataTypeHint[];
 //# sourceMappingURL=PostgreSQL.d.ts.map

package/dist/constants/sql/dataType/SQLite.d.ts

@@ -1,6 +1,8 @@
 import { DataTypeHint } from '.';
 /**
- * https://www.sqlite.org/datatype3.html
+ * https://www.sqlite.org/datatype3.html, and BOOL, DEC, TIME and TIMESTAMP,
+ * which SQLite schemas use too: Django declares a boolean as bool and a time
+ * as time, and DEC, standard SQL's DECIMAL, takes the same NUMERIC affinity.
  */
 export declare const SQLiteTypes: DataTypeHint[];
 //# sourceMappingURL=SQLite.d.ts.map

package/dist/engine/actions.d.ts

@@ -22,11 +22,24 @@ import { actions$ as tableActions$ } from './modules/table/generator.actions';
 import { ActionMap as TableColumnActionMap } from './modules/table-column/actions';
 import { actions as tableColumnActions } from './modules/table-column/atom.actions';
 import { actions$ as tableColumnActions$ } from './modules/table-column/generator.actions';
-export type Actions = typeof editorActions & typeof editorActions$ & typeof indexActions & typeof indexActions$ & typeof indexColumnActions & typeof indexColumnActions$ & typeof memoActions & typeof memoActions$ & typeof relationshipActions & typeof relationshipActions$ & typeof settingsActions & typeof settingsActions$ & typeof tableActions & typeof tableActions$ & typeof tableColumnActions & typeof tableColumnActions$;
-export type RootActionMap = EditorActionMap & TableActionMap & TableColumnActionMap & MemoActionMap & RelationshipActionMap & SettingsActionMap & IndexActionMap & IndexColumnActionMap;
+import { ActionMap as TableGroupActionMap } from './modules/table-group/actions';
+import { actions as tableGroupActions } from './modules/table-group/atom.actions';
+import { actions$ as tableGroupActions$ } from './modules/table-group/generator.actions';
+export type Actions = typeof editorActions & typeof editorActions$ & typeof indexActions & typeof indexActions$ & typeof indexColumnActions & typeof indexColumnActions$ & typeof memoActions & typeof memoActions$ & typeof relationshipActions & typeof relationshipActions$ & typeof settingsActions & typeof settingsActions$ & typeof tableActions & typeof tableActions$ & typeof tableColumnActions & typeof tableColumnActions$ & typeof tableGroupActions & typeof tableGroupActions$;
+export type RootActionMap = EditorActionMap & TableActionMap & TableColumnActionMap & MemoActionMap & RelationshipActionMap & SettingsActionMap & IndexActionMap & IndexColumnActionMap & TableGroupActionMap;
 export type ActionType = keyof RootActionMap;
 export declare const actions: Actions;
 export declare const ChangeActionTypes: ReadonlyArray<ActionType>;
+/**
+ * What a replica reports as a change: every change, and the save switch the
+ * locks replaced, which changes nothing yet owes the hub that relayed it a save.
+ */
+export declare const ReplicaChangeActionTypes: ReadonlyArray<ActionType>;
+/**
+ * What a replica applies: what it reports, and the registers a window answers
+ * a join with, which change no saved byte and so owe no hub a save.
+ */
+export declare const ReplicaActionTypes: ReadonlyArray<ActionType>;
 export declare const ReadonlyIgnoreActionTypes: ReadonlyArray<ActionType>;
 /**
  * What a view keeps from the document while it is active: every edit a
@@ -34,6 +47,11 @@ export declare const ReadonlyIgnoreActionTypes: ReadonlyArray<ActionType>;
  * a view cannot stand in the way of and answers by closing.
  */
 export declare const ViewIgnoreActionTypes: ReadonlyArray<ActionType>;
+/**
+ * The lock that holds each setting action out of the element's change event:
+ * while it is on, the action changes the screen and never the file.
+ */
+export declare const LockSettingActionTypes: Readonly<Partial<Record<ActionType, number>>>;
 export declare const SharedStreamActionTypes: ReadonlyArray<ActionType>;
 export declare const SharedActionTypes: ReadonlyArray<ActionType>;
 export declare const SharedFollowingActionTypes: ReadonlyArray<ActionType>;

package/dist/engine/context.d.ts

@@ -1,6 +1,12 @@
 import { Clock } from './clock';
 export type EngineContext = {
     toWidth: (text: string) => number;
+    /**
+     * False in a store that draws nothing, a peer's or a replica's: its load
+     * places each relationship's anchors and routes no connector, which only a
+     * drawing reads. Any other store routes them.
+     */
+    routes?: boolean;
     clock: Clock;
 };
 export type InjectEngineContext = Omit<EngineContext, 'clock'>;