@dineug/erd-editor 3.9.2 → 4.0.0

package/dist/components/primitives/select/Select.styles.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The chevron over the list's end, the clicks passing through it to the list.
+ * Its ink starts 5/24 into its 14 px box, so 7 px off the edge puts it 8.9 px
+ * past the border, where a value's first letter stands past its 8 px padding.
+ */
+export declare const chevron: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * A native list in the editor's colours, the browser's arrow off and the
+ * editor's chevron in its place, a value never running under it; its popup
+ * takes the appearance from color-scheme.
+ */
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=Select.styles.d.ts.map

package/dist/components/primitives/text-input/TextInput.d.ts

@@ -3,6 +3,8 @@ export type TextInputProps = {
     class?: any;
     title?: string;
     placeholder?: string;
+    /** auto for what a reader types, which runs in its own direction whatever the page's, once there is some. */
+    dir?: 'auto';
     readonly?: boolean;
     disabled?: boolean;
     width?: number;

package/dist/components/primitives/toast/Toast.d.ts

@@ -1,12 +1,16 @@
 import { DOMTemplateLiterals, FC } from '@dineug/r-html';
+/** What became of the thing a toast reports: done, or not done. */
+export type ToastTone = 'success' | 'error';
 export type ToastProps = {
     title?: DOMTemplateLiterals | string;
     description?: DOMTemplateLiterals | string;
     action?: DOMTemplateLiterals | string;
-    /** The thing reported is still running, which a turning ring says. */
+    /** The thing reported is still running, which lucide's turning loader says. */
     busy?: boolean;
     /** How far along it is, from 0 to 1, which the ring fills up by. */
     progress?: number;
+    /** How it ended, which a check or a warning sign in the tone's color says. */
+    tone?: ToastTone;
 };
 declare const Toast: FC<ToastProps>;
 export default Toast;

package/dist/components/primitives/toast/Toast.styles.d.ts

@@ -1,7 +1,7 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
 /**
- * The ring beside the text of a toast that reports something still running.
- * A busy one turns a quarter of it; one with a progress fills it from the top.
+ * What stands beside the text: lucide's turning loader while busy, a ring that
+ * fills from the top with a progress, or the mark of a tone in its own color.
  */
 export declare const indicator: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const textWrap: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/components/quick-search/QuickSearch.d.ts

@@ -1,5 +1,6 @@
 import { FC } from '@dineug/r-html';
-export type QuickSearchProps = {};
+import { PalettePreferences } from './actions';
+export type QuickSearchProps = PalettePreferences;
 declare const QuickSearch: FC<QuickSearchProps>;
 export default QuickSearch;
 //# sourceMappingURL=QuickSearch.d.ts.map

package/dist/components/quick-search/QuickSearch.styles.d.ts

@@ -1,6 +1,12 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const container: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const field: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const search: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const scope: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hint: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const hintItem: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const empty: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const prefix: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const list: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const action: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const icon: import('@dineug/r-html').CSSTemplateLiterals;

package/dist/components/quick-search/actions.d.ts

@@ -1,15 +1,73 @@
 import { DOMTemplateLiterals } from '@dineug/r-html';
 import { AppContext } from '../appContext';
+import { RootState } from '../../engine/state';
+import { LocaleOption } from '../../i18n/locales';
+import { LabeledMenu } from '../../i18n/menuLabel';
+import { I18n, PlainMessageKey } from '../../i18n/translate';
+import { AppearanceOption } from '../../themes/radix-ui-theme';
+import { FindReplaceQuery } from '../../utils/emitter';
+import { FindMatch } from '../../utils/find-replace';
 export type Action = {
     icon?: DOMTemplateLiterals | null;
     name: string;
     keywords?: string;
     shortcut?: string;
+    /** The table a row jumps to, whose keyword names the kind of row, not the table. */
+    tableId?: string;
+    /** What choosing the row types into the input, which stays open, instead of running a command. */
+    insert?: string;
+    /** The English of a translated name and keywords, each its own text, which a search also reads and the list never shows. */
+    alias?: string[];
+    /** The option in force among a submenu's rows, which the submenu opens on. */
+    checked?: boolean;
+    /** The message key of a row opening a submenu, by which an open palette finds that submenu again in a rebuilt level. */
+    id?: PlainMessageKey;
     filter?: (app: AppContext) => boolean;
     perform?: (app: AppContext) => void;
     next?: Action[];
 };
+/** What names a row: a message key, or a shared menu whose name stays as written where it has no key. */
+type RowLabel = PlainMessageKey | LabeledMenu;
+/**
+ * A row's name and keywords in the reader's language. The English of each one
+ * a translation changes goes into its alias apart, so a search scores it as in
+ * English and a command is found by its English words too; English has none.
+ */
+export declare function named(i18n: Pick<I18n, 't'>, label: RowLabel, keywordsKey?: PlainMessageKey): Pick<Action, 'name' | 'keywords' | 'alias'>;
+/**
+ * Whether a row holds the keyword: as typed, or by its Hangul letters, which
+ * an IME spells out one jamo at a time and a choseong search abbreviates.
+ */
+export declare function keywordHolder(keyword: string): (action: Action) => boolean;
+/**
+ * How loose a fuzzy hit may be: stricter than fuse.js's 0.6, which fuzzed most
+ * words to some command (memo to the relationships, #us to orders), while a
+ * typo such as tabel still finds New Table. A row holding the keyword stays.
+ */
+export declare const SEARCH_THRESHOLD = 0.4;
 export declare function searchActions(actions: Action[], keyword: string): Action[];
-export declare function createScopeActions(app: AppContext): Action[];
-export declare const allScopeActions: Action[];
+/** The theme and the display language the element holds, each given only while it offers that picker. */
+export type PalettePreferences = {
+    appearance?: AppearanceOption;
+    locale?: LocaleOption;
+};
+/**
+ * The palette's top level: the commands of every tab, then a jump to each
+ * table, which only the # prefix lists, each in the reader's language. Theme
+ * and Display Language show on every tab, each only while its picker is given.
+ */
+export declare function createScopeActions(app: AppContext, i18n?: I18n, preferences?: PalettePreferences): Action[];
+/**
+ * Theme and Display Language, each only while the element offers its picker,
+ * with a check on the option in force. A pick goes through the emitter as the
+ * pickers' own do, so the host hears it; a language is named in itself.
+ */
+export declare function createPreferenceActions(i18n: I18n, { appearance, locale }: PalettePreferences): Action[];
+/** The row for one field a search found, saying where it is, which stands the reader on it when chosen. */
+export declare function createMatchAction(state: RootState, match: FindMatch, i18n?: I18n): Action;
+/** The row handing a search to Find and Replace, named with the count the panel opens on. */
+export declare function createShowAllAction(count: number, payload: FindReplaceQuery, i18n?: I18n): Action;
+/** The five tabs the Tab row opens, each but the one shown. */
+export declare function createTabActions(i18n?: I18n): Action[];
+export {};
 //# sourceMappingURL=actions.d.ts.map

package/dist/components/quick-search/hangul.d.ts

@@ -0,0 +1,79 @@
+import { Matcher, TextRange } from '../../utils/find-replace';
+import { FindChunksArgs } from '../../utils/highlightWords';
+export type HangulForms = {
+    /** The text spelled in jamo letter by letter and lower-cased, as disassemble spells it. */
+    jamo: string;
+    /** The initial of each syllable and each lone consonant, a cluster split in two, run together without the spaces. */
+    choseong: string;
+};
+/** A text's forms, spelled once and kept until the palette next opens or closes, since it reads every field again on each keystroke. */
+export declare function hangulFormsOf(text: string): HangulForms;
+/** Lets go of every form kept, as the palette opens and closes: they last one open and outlive no text the document dropped. */
+export declare function clearHangulForms(): void;
+export type HangulQuery = {
+    /** The keyword spelled in jamo, which the text's jamo has to hold. */
+    jamo: string;
+    /** The consonants of a keyword typed as initials alone, a cluster split in two, spaces dropped; null for any other keyword. */
+    choseong: string | null;
+};
+/**
+ * How a keyword reads as a Hangul search, or null when it holds no Hangul and
+ * the palette matches as it always has.
+ *
+ * @example
+ * hangulQueryOf('ㅅㅇㅈ'); // { jamo: 'ㅅㅇㅈ', choseong: 'ㅅㅇㅈ' }
+ * hangulQueryOf('ㅄ'); // { jamo: 'ㅂㅅ', choseong: 'ㅂㅅ' }
+ * hangulQueryOf('사요'); // { jamo: 'ㅅㅏㅇㅛ', choseong: null }
+ */
+export declare function hangulQueryOf(keyword: string): HangulQuery | null;
+/** How closely a text holds a Hangul keyword: all of it, from its start, or somewhere inside. */
+export declare const HangulTier: {
+    readonly exact: 0;
+    readonly prefix: 1;
+    readonly inside: 2;
+};
+export type HangulTier = (typeof HangulTier)[keyof typeof HangulTier];
+/**
+ * How closely a text holds a Hangul keyword, by its jamo or, for a keyword of
+ * initials, by the initials of its syllables; null when it holds it neither way.
+ */
+export declare function hangulTier(text: string, query: HangulQuery): HangulTier | null;
+/**
+ * Every place a text holds a Hangul keyword, as whole letters of the text in
+ * order of where they start, so a jamo typed mid-syllable covers the syllables
+ * it spells: 상 in 사용자 covers 사용.
+ */
+export declare function hangulRanges(text: string, query: HangulQuery): TextRange[];
+/** How a text holds the keyword: as typed, which Find and Replace finds too, and where; or by its Hangul letters alone, and how closely. */
+export type TextHit = (TextRange & {
+    literal: true;
+}) | {
+    literal: false;
+    tier: HangulTier;
+};
+/**
+ * Whether a text holds the keyword: as typed, or failing that by its Hangul
+ * letters, which only the palette reads. Where those letters lie waits for
+ * hitRange, which spells the text again.
+ */
+export declare function matchText(text: string, matcher: Matcher, hangul: HangulQuery | null): TextHit | null;
+/**
+ * The first place a text holds a hit, which for one its Hangul letters hold
+ * spells the text again, so a list reads it only for the rows it shows.
+ */
+export declare function hitRange(text: string, hit: TextHit, hangul: HangulQuery | null): TextRange;
+/**
+ * Hits in a Hangul search's order: those holding the keyword as typed first,
+ * as they came, the way a search without Hangul lists them, then those only its
+ * letters hold, closest first and as they came within a tier.
+ */
+export declare function rankHits<T extends {
+    hit: TextHit;
+}>(hits: T[]): T[];
+/**
+ * The ranges a palette row lights up: each word where the text holds it as
+ * typed, and a Hangul word where the text holds it by its letters, widened to
+ * whole syllables. HighlightedText merges the ones that overlap or touch.
+ */
+export declare function findPaletteChunks(args: FindChunksArgs): TextRange[];
+//# sourceMappingURL=hangul.d.ts.map

package/dist/components/quick-search/paletteQuery.d.ts

@@ -0,0 +1,38 @@
+import { I18n, PlainMessageKey } from '../../i18n/translate';
+import { ValuesType } from '../../internal-types';
+export declare const PaletteScope: {
+    readonly tables: "tables";
+    readonly columns: "columns";
+    readonly text: "text";
+    readonly help: "help";
+};
+export type PaletteScope = ValuesType<typeof PaletteScope>;
+export type PalettePrefix = {
+    prefix: string;
+    scope: PaletteScope;
+    labelKey: PlainMessageKey;
+    descriptionKey: PlainMessageKey;
+};
+/** The characters that, typed first, narrow the palette to one kind of row, in the order its hint lists them. */
+export declare const PALETTE_PREFIXES: ReadonlyArray<PalettePrefix>;
+export type PaletteQuery = {
+    /** The kind of row the prefix asks for, or null with no prefix, which lists the commands. */
+    scope: PaletteScope | null;
+    /** What is searched for, without the prefix, the space after it or the table part. */
+    keyword: string;
+    /** The table part of a column search, the text before its first dot; null when it has no dot. */
+    table: string | null;
+};
+/** The label the palette shows beside its input while a prefix narrows the list, in the reader's language. */
+export declare function scopeLabel(scope: PaletteScope, i18n?: Pick<I18n, 't'>): string;
+/**
+ * Reads what is typed into the palette: a prefix counts only as the first
+ * character past any space, in its full-width form too, a space may follow it,
+ * and a column search splits on its first dot.
+ *
+ * @example
+ * parsePaletteQuery('@users.em'); // { scope: 'columns', keyword: 'em', table: 'users' }
+ * parsePaletteQuery(':login email'); // { scope: 'text', keyword: 'login email', table: null }
+ */
+export declare function parsePaletteQuery(value: string): PaletteQuery;
+//# sourceMappingURL=paletteQuery.d.ts.map

package/dist/components/quick-search/scopedActions.d.ts

@@ -0,0 +1,42 @@
+import { AppContext } from '../appContext';
+import { I18n } from '../../i18n/translate';
+import { FindField } from '../../utils/find-replace';
+import { Action } from './actions';
+import { PaletteQuery, PaletteScope } from './paletteQuery';
+/** How many rows a prefixed list shows, few enough to draw at once. */
+export declare const SCOPED_ACTION_LIMIT = 100;
+/** What the colon searches: the free text, never a name. */
+export declare const TEXT_FIELDS: FindField[];
+/**
+ * The rows of a level a scope hands to the fuzzy search: the commands without
+ * a prefix, the tables after # alone, and none for a scope whose rows are read
+ * from the document. A submenu holds commands only.
+ */
+export declare function scopeBase(actions: Action[], scope: PaletteScope | null): Action[];
+/**
+ * What the top level lists for a query, from the fuzzy hits of its scope: the
+ * commands, then the prefixes when none holds the keyword; the tables; or rows
+ * read from the document for the columns, the free text and the help.
+ */
+export declare function paletteRows(app: AppContext, found: Action[], { scope, keyword, table }: PaletteQuery, i18n?: I18n): Action[];
+/**
+ * The table rows the keyword fuzzes to, those holding it as typed or by its
+ * Hangul letters first, up to the scoped limit, past which a table whose name
+ * the panel finds it in hands the search to Find and Replace over the names.
+ */
+export declare function rankTableActions(app: AppContext, found: Action[], keyword: string, i18n?: I18n): Action[];
+/**
+ * One row a field of the kinds given holding the keyword, Hangul letters too,
+ * or every column or text, up to the scoped limit, past which one holding it as
+ * typed hands it to Find and Replace over those kinds, without the table part.
+ */
+export declare function createFieldActions(app: AppContext, fields: FindField[], keyword: string, table?: string | null, i18n?: I18n): Action[];
+/** The prefixes as rows, each typing its character into the input when chosen; a keyword fuzzes them. */
+export declare function createHelpActions(keyword?: string, i18n?: I18n): Action[];
+/**
+ * The prefixes that search the document as rows offering the keyword to one,
+ * what a search with no prefix lists below its commands once none holds it:
+ * choosing one types its prefix before the keyword, so users becomes #users.
+ */
+export declare function createPrefixActions(keyword: string, i18n?: I18n): Action[];
+//# sourceMappingURL=scopedActions.d.ts.map

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

@@ -1,7 +1,9 @@
 import { FC } from '@dineug/r-html';
 export type SchemaSQLProps = {
     isDarkMode: boolean;
+    /** One table's DDL, as Table Properties shows it: always created, no options. */
     tableId?: string;
+    readonly?: boolean;
 };
 declare const SchemaSQL: FC<SchemaSQLProps>;
 export default SchemaSQL;

package/dist/components/schema-sql/SchemaSQL.styles.d.ts

@@ -1,2 +1,9 @@
+/** The code and, beside it, the options panel. */
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+/** The code takes what the panel leaves, and no more. */
+export declare const code: import('@dineug/r-html').CSSTemplateLiterals;
+/** Why the code is empty while no table is chosen, centred over it in any language. */
+export declare const empty: import('@dineug/r-html').CSSTemplateLiterals;
+/** Show options, over the code's own colour so it reads above the text. */
+export declare const show: import('@dineug/r-html').CSSTemplateLiterals;
 //# sourceMappingURL=SchemaSQL.styles.d.ts.map

package/dist/components/schema-sql/schema-sql-context-menu/SchemaSQLContextMenu.d.ts

@@ -1,5 +1,8 @@
 import { FC } from '@dineug/r-html';
 export type SchemaSQLContextMenuProps = {
+    /** The whole document's tab, which adds the statements, the header, the panel and Save file to the menu. */
+    full?: boolean;
+    onSave?: () => void;
     onClose: () => void;
 };
 declare const SchemaSQLContextMenu: FC<SchemaSQLContextMenuProps>;

package/dist/components/schema-sql/schema-sql-context-menu/menus/bracketMenus.d.ts

@@ -1,12 +1,15 @@
 import { AppContext } from '../../../appContext';
+import { PlainMessageKey } from '../../../../i18n/translate';
 type Menu = {
     name: string;
+    labelKey?: PlainMessageKey;
     value: number;
 };
 export declare const menus: Menu[];
 export declare function createBracketMenus({ store }: AppContext): {
     checked: boolean;
     name: string;
+    labelKey: PlainMessageKey | undefined;
     onClick: () => void;
 }[];
 export {};

package/dist/components/schema-sql/schema-sql-context-menu/menus/headerMenus.d.ts

@@ -0,0 +1,29 @@
+import { AppContext } from '../../../appContext';
+import { I18n, PlainMessageKey } from '../../../../i18n/translate';
+import { SchemaSQLHeader } from '../../../../utils/schema-sql';
+import { SchemaSQLSupport } from '../../../../utils/schema-sql/options';
+type Menu = {
+    id: SchemaSQLHeader;
+    name: string;
+    labelKey?: PlainMessageKey;
+};
+/** No header, then the two as the SQL they write names them, which no language translates. */
+export declare const menus: ReadonlyArray<Menu>;
+/** Whether a database writes the header; every one can write none. */
+export declare const isHeaderSupported: ({ headers }: SchemaSQLSupport, id: SchemaSQLHeader) => boolean;
+/** What a header writes in a database, or nothing for none or one it lacks. */
+export declare const headerHint: (database: number, id: SchemaSQLHeader) => string | undefined;
+/**
+ * The Header rows of the Schema SQL menu, ruled as the Statements rows are:
+ * None in the reader's language, the two headers as SQL.
+ */
+export declare function createHeaderMenus(app: Pick<AppContext, 'store'>, i18n: Pick<I18n, 't'>): {
+    id: SchemaSQLHeader;
+    name: string;
+    literal: boolean;
+    checked: boolean;
+    note: string | null;
+    onClick: (() => void) | undefined;
+}[];
+export {};
+//# sourceMappingURL=headerMenus.d.ts.map

package/dist/components/schema-sql/schema-sql-context-menu/menus/statementsMenus.d.ts

@@ -0,0 +1,27 @@
+import { AppContext } from '../../../appContext';
+import { I18n } from '../../../../i18n/translate';
+import { SchemaSQLStatements } from '../../../../utils/schema-sql';
+import { SchemaSQLSupport } from '../../../../utils/schema-sql/options';
+type Menu = {
+    id: SchemaSQLStatements;
+    name: string;
+};
+/** The three ways the tables are written, named alike in every language, as the owner decided. */
+export declare const menus: ReadonlyArray<Menu>;
+/** Whether a database writes the statements: every one drops and re-creates, not every one checks first. */
+export declare const isStatementsSupported: ({ ifNotExists }: SchemaSQLSupport, id: SchemaSQLStatements) => boolean;
+/** A database by the name its menu gives it, or nothing for a value no menu lists. */
+export declare const databaseLabel: (database: number) => string;
+/**
+ * The Statements rows of the Schema SQL menu: the one the database writes
+ * checked, one it lacks noted and inert, a pick kept for this window alone.
+ */
+export declare function createStatementsMenus(app: Pick<AppContext, 'store'>, i18n: Pick<I18n, 't'>): {
+    id: SchemaSQLStatements;
+    name: string;
+    checked: boolean;
+    note: string | null;
+    onClick: (() => void) | undefined;
+}[];
+export {};
+//# sourceMappingURL=statementsMenus.d.ts.map

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