@dineug/erd-editor 3.10.0 → 4.1.0

package/dist/components/primitives/context-menu/context-menu-separator/ContextMenuSeparator.d.ts

@@ -0,0 +1,8 @@
+import { FC } from '@dineug/r-html';
+/**
+ * A rule between groups of rows, which opens and runs nothing. A sibling of the
+ * rows, never their wrapper, since a row finds its menu by its parent's data-id.
+ */
+declare const ContextMenuSeparator: FC;
+export default ContextMenuSeparator;
+//# sourceMappingURL=ContextMenuSeparator.d.ts.map

package/dist/components/primitives/context-menu/context-menu-separator/ContextMenuSeparator.styles.d.ts

@@ -0,0 +1,2 @@
+export declare const separator: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=ContextMenuSeparator.styles.d.ts.map

package/dist/components/primitives/context-menu/menu/Menu.d.ts

@@ -2,6 +2,8 @@ import { DOMTemplateLiterals, FC } from '@dineug/r-html';
 export type MenuProps = {
     icon?: DOMTemplateLiterals | string | null;
     name: DOMTemplateLiterals | string;
+    /** A name kept as written, a vendor or a code language such as C#, which reads left to right in any language. */
+    literal?: boolean;
     right?: DOMTemplateLiterals | string | null;
 };
 declare const Menu: FC<MenuProps>;

package/dist/components/primitives/context-menu/submenu-chevron/SubmenuChevron.d.ts

@@ -0,0 +1,5 @@
+import { FC } from '@dineug/r-html';
+/** The mark of a row that opens a submenu, pointing the way it opens: right, or left for a right-to-left reader. */
+declare const SubmenuChevron: FC;
+export default SubmenuChevron;
+//# sourceMappingURL=SubmenuChevron.d.ts.map

package/dist/components/primitives/dialog/Dialog.d.ts

@@ -0,0 +1,21 @@
+import { DOMTemplateLiterals, FC } from '@dineug/r-html';
+export type DialogProps = {
+    /** The name the dialog is announced by. */
+    label: string;
+    /** The widest the box grows, in pixels; it narrows with the editor. */
+    maxWidth: number;
+    onClose: () => void;
+    children: DOMTemplateLiterals;
+};
+/** Marks the control a dialog focuses when it opens; without one the box takes the focus. */
+export declare const AUTOFOCUS_ATTRIBUTE = "data-autofocus";
+/** The editor width under which a dialog stacks what stands side by side in it. */
+export declare const DIALOG_STACK_BELOW = 640;
+/**
+ * A modal box over the editor. Escape and a press on the dim around it close
+ * it, and once it is gone the editor takes the keyboard back, or the keyboard
+ * falls to the page and every shortcut stops.
+ */
+declare const Dialog: FC<DialogProps>;
+export default Dialog;
+//# sourceMappingURL=Dialog.d.ts.map

package/dist/components/primitives/dialog/Dialog.styles.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Dims the whole editor and centres the box in it. It stacks one under the
+ * toasts, which report what its buttons did, and the palette, drawn after it
+ * at the toasts' height, still opens over it.
+ */
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * The box over the dim, as tall as its content and never past the editor; a
+ * short editor scrolls it, so the controls at its foot stay in reach.
+ */
+export declare const content: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=Dialog.styles.d.ts.map

package/dist/components/primitives/highlighted-text/HighlightedText.d.ts

@@ -1,9 +1,6 @@
 import { FC } from '@dineug/r-html';
-import { findAll } from 'highlight-words-core';
-export type HighlightedTextProps = Parameters<typeof findAll>[0] & {
-    searchWords: string[];
-    textToHighlight: string;
-};
+import { FindAllArgs } from '../../../utils/highlightWords';
+export type HighlightedTextProps = FindAllArgs;
 declare const HighlightedText: FC<HighlightedTextProps>;
 export default HighlightedText;
 //# sourceMappingURL=HighlightedText.d.ts.map

package/dist/components/primitives/icon/icons.d.ts

@@ -5,40 +5,60 @@ export declare const ICON_STROKE_WIDTH = 2;
 export type IconNodeChild = IconNode[number];
 declare const LUCIDE_ICON: {
     'arrow-down': IconNode;
+    'arrow-left': IconNode;
     'arrow-right': IconNode;
     'arrow-up': IconNode;
     atom: IconNode;
     braces: IconNode;
     brackets: IconNode;
     'case-sensitive': IconNode;
+    'case-upper': IconNode;
     check: IconNode;
     'chevron-down': IconNode;
     'chevron-right': IconNode;
+    'chevrons-down-up': IconNode;
     code: IconNode;
-    'columns-2': IconNode;
     contrast: IconNode;
     copy: IconNode;
     database: IconNode;
-    diff: IconNode;
+    download: IconNode;
+    ellipsis: IconNode;
     'external-link': IconNode;
     eye: IconNode;
     'file-diff': IconNode;
     'file-image': IconNode;
     'file-input': IconNode;
     'file-output': IconNode;
+    folder: IconNode;
+    'folder-open': IconNode;
     fullscreen: IconNode;
     'grip-vertical': IconNode;
+    group: IconNode;
     hand: IconNode;
+    keyboard: IconNode;
     'key-round': IconNode;
+    languages: IconNode;
+    link: IconNode;
+    list: IconNode;
+    'list-tree': IconNode;
+    'loader-circle': IconNode;
     lock: IconNode;
+    'lock-open': IconNode;
+    logs: IconNode;
     maximize: IconNode;
     'message-square': IconNode;
     minimize: IconNode;
     minus: IconNode;
+    monitor: IconNode;
     'moon-star': IconNode;
     'mouse-pointer-2': IconNode;
     network: IconNode;
     palette: IconNode;
+    'panel-right': IconNode;
+    'panel-right-close': IconNode;
+    'panel-right-open': IconNode;
+    pencil: IconNode;
+    pipette: IconNode;
     plus: IconNode;
     'redo-2': IconNode;
     'refresh-cw': IconNode;
@@ -54,8 +74,9 @@ declare const LUCIDE_ICON: {
     sun: IconNode;
     'table-2': IconNode;
     'table-properties': IconNode;
-    'text-search': IconNode;
+    'triangle-alert': IconNode;
     'undo-2': IconNode;
+    ungroup: IconNode;
     'wand-sparkles': IconNode;
     waypoints: IconNode;
     'whole-word': IconNode;

package/dist/components/primitives/sash/Sash.d.ts

@@ -22,6 +22,7 @@ export type SashProps = {
     left?: number;
     onMove?: (dragMove: DragMove) => void;
     onMousedown?: (event: MouseEvent) => void;
+    onDblclick?: (event: MouseEvent) => void;
 };
 declare const Sash: FC<SashProps>;
 export default Sash;

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

@@ -0,0 +1,18 @@
+import { DOMTemplateLiterals, FC } from '@dineug/r-html';
+/** The chevron's box; its ink is 5/24 inside it on each side, as lucide draws it. */
+export declare const SELECT_CHEVRON_SIZE = 14;
+export type SelectProps = {
+    /** The box's width and place, which the list fills. */
+    class?: any;
+    /** A setting nothing reads now, its value and chevron dimmed, still to be changed. */
+    dimmed?: boolean;
+    /** The native select, its options, name and change its own. */
+    children: DOMTemplateLiterals;
+};
+/**
+ * A native list drawn in the editor's look: the select a caller writes, with
+ * the editor's chevron at its end, on the left for a right-to-left reader.
+ */
+declare const Select: FC<SelectProps>;
+export default Select;
+//# sourceMappingURL=Select.d.ts.map

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/primitives/tree/Tree.d.ts

@@ -0,0 +1,30 @@
+import { DOMTemplateLiterals, FC } from '@dineug/r-html';
+import { TreeRow } from './treeModel';
+export declare const TREE_ROW_HEIGHT = 22;
+export declare const TREE_OVERSCAN = 8;
+export type TreeProps<T = any> = {
+    rows: ReadonlyArray<TreeRow<T>>;
+    /** The row the keyboard is on, named to a reader by aria-activedescendant. */
+    activeId: string | null;
+    /** The row a host marks as the current one, such as the match it jumped to. */
+    currentId?: string | null;
+    /** Scrolls this row into view each time a different id arrives; a null between two arrivals of one id scrolls it again. */
+    revealId?: string | null;
+    label: string;
+    dir?: 'ltr' | 'rtl';
+    /** Read once as the tree mounts, so a scroll position kept outside comes back. */
+    getScrollTop: () => number;
+    onScroll?: (top: number) => void;
+    onToggle?: (id: string, expanded: boolean) => void;
+    onActivate?: (row: TreeRow<T>) => void;
+    onActiveChange?: (id: string) => void;
+    renderRow: (row: TreeRow<T>) => DOMTemplateLiterals;
+};
+/**
+ * A virtualized tree with fixed-height rows. It renders the rows in view, the
+ * overscan and the active row, answers the tree keys and leaves every policy to
+ * its host: what a row shows, what activating one does, Escape and the chords.
+ */
+declare const Tree: FC<TreeProps>;
+export default Tree;
+//# sourceMappingURL=Tree.d.ts.map

package/dist/components/primitives/tree/Tree.styles.d.ts

@@ -0,0 +1,5 @@
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const space: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const row: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const twisty: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=Tree.styles.d.ts.map

package/dist/components/primitives/tree/treeModel.d.ts

@@ -0,0 +1,42 @@
+/**
+ * One node of a tree a host builds. Its children are asked for only while it
+ * is expanded, so a host can hand over a large document without building rows
+ * for what stays folded.
+ */
+export type TreeNode<T = unknown> = {
+    id: string;
+    hasChildren: boolean;
+    children: () => ReadonlyArray<TreeNode<T>>;
+    data: T;
+};
+/** A node as the tree lays it out: its depth and its place among its siblings. */
+export type TreeRow<T = unknown> = {
+    node: TreeNode<T>;
+    /** One for a root. */
+    level: number;
+    setSize: number;
+    /** One for the first sibling. */
+    posInSet: number;
+    expanded: boolean;
+    parentId: string | null;
+};
+export type ExpandedIds = Readonly<Record<string, true>>;
+/** The rows a tree shows: every root, and the children of each expanded node, depth first. */
+export declare function flattenTree<T>(roots: ReadonlyArray<TreeNode<T>>, expanded: ExpandedIds): TreeRow<T>[];
+/** What a key asks of the tree: move the active row, or fold or unfold one. */
+export type TreeMove = {
+    type: 'focus';
+    id: string;
+    index: number;
+} | {
+    type: 'toggle';
+    id: string;
+    expanded: boolean;
+};
+/**
+ * Reads a tree key the way the WAI-ARIA tree pattern does. Up and Down step,
+ * Home and End go to either end, the inline end unfolds or steps into the
+ * first child and the inline start folds or steps out, mirrored right to left.
+ */
+export declare function moveFocus<T>(rows: ReadonlyArray<TreeRow<T>>, activeId: string | null, key: string, dir?: 'ltr' | 'rtl'): TreeMove | null;
+//# sourceMappingURL=treeModel.d.ts.map

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

@@ -8,6 +8,7 @@ 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 space: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const action: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const icon: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const name: import('@dineug/r-html').CSSTemplateLiterals;

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

@@ -1,7 +1,10 @@
 import { DOMTemplateLiterals } from '@dineug/r-html';
 import { AppContext } from '../appContext';
 import { RootState } from '../../engine/state';
-import { FindReplaceQuery } from '../../utils/emitter';
+import { LocaleOption } from '../../i18n/locales';
+import { LabeledMenu } from '../../i18n/menuLabel';
+import { I18n, PlainMessageKey } from '../../i18n/translate';
+import { AppearanceOption } from '../../themes/radix-ui-theme';
 import { FindMatch } from '../../utils/find-replace';
 export type Action = {
     icon?: DOMTemplateLiterals | null;
@@ -12,10 +15,24 @@ export type Action = {
     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.
@@ -28,11 +45,26 @@ export declare function keywordHolder(keyword: string): (action: Action) => bool
  */
 export declare const SEARCH_THRESHOLD = 0.4;
 export declare function searchActions(actions: Action[], keyword: string): Action[];
-/** The palette's top level: the commands of every tab, then a jump to each table, which only the # prefix lists. */
-export declare function createScopeActions(app: AppContext): 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): 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): Action;
-export declare const allScopeActions: Action[];
+export declare function createMatchAction(state: RootState, match: FindMatch, 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

@@ -1,5 +1,5 @@
-import { Chunk, FindChunksArgs } from 'highlight-words-core';
 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;
@@ -44,18 +44,24 @@ export declare function hangulTier(text: string, query: HangulQuery): HangulTier
  * it spells: 상 in 사용자 covers 사용.
  */
 export declare function hangulRanges(text: string, query: HangulQuery): TextRange[];
-/** Where a text holds the keyword: as typed, which Find and Replace finds too, or by its Hangul letters alone, and how closely. */
-export type TextHit = 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;
-});
+};
 /**
- * The first place a text holds the keyword: as typed, or failing that by its
- * Hangul letters, which only the palette reads.
+ * 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
@@ -65,9 +71,9 @@ export declare function rankHits<T extends {
     hit: TextHit;
 }>(hits: T[]): T[];
 /**
- * The chunks a palette row lights up: each word where the text holds it as
+ * 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.
+ * whole syllables. HighlightedText merges the ones that overlap or touch.
  */
-export declare function findPaletteChunks(args: FindChunksArgs): Chunk[];
+export declare function findPaletteChunks(args: FindChunksArgs): TextRange[];
 //# sourceMappingURL=hangul.d.ts.map

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

@@ -0,0 +1,7 @@
+/** The height of one palette row, which the list lays out every row at. */
+export declare const PALETTE_ROW_HEIGHT = 45;
+/** The tallest the list stands before it scrolls. */
+export declare const PALETTE_LIST_MAX_HEIGHT = 400;
+/** How tall the list stands for so many rows: all of them, up to its tallest. */
+export declare const paletteListHeight: (count: number) => number;
+//# sourceMappingURL=paletteList.d.ts.map

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

@@ -1,3 +1,4 @@
+import { I18n, PlainMessageKey } from '../../i18n/translate';
 import { ValuesType } from '../../internal-types';
 export declare const PaletteScope: {
     readonly tables: "tables";
@@ -9,8 +10,8 @@ export type PaletteScope = ValuesType<typeof PaletteScope>;
 export type PalettePrefix = {
     prefix: string;
     scope: PaletteScope;
-    label: string;
-    description: string;
+    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>;
@@ -22,8 +23,8 @@ export type PaletteQuery = {
     /** 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. */
-export declare const scopeLabel: (scope: PaletteScope) => string;
+/** 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,

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

@@ -1,9 +1,8 @@
 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[];
 /**
@@ -17,25 +16,21 @@ export declare function scopeBase(actions: Action[], scope: PaletteScope | null)
  * 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): Action[];
+export declare function paletteRows(app: AppContext, found: Action[], { scope, keyword, table }: PaletteQuery, i18n?: I18n): Action[];
+/** The table rows the keyword fuzzes to, every one, those holding it as typed or by its Hangul letters first. */
+export declare function rankTableActions(found: Action[], keyword: string): 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.
+ * One row for each field of the kinds given holding the keyword, Hangul letters
+ * too, or for every column or text that is not empty while there is none, the
+ * table part narrowing a column search; the list draws only the rows in view.
  */
-export declare function rankTableActions(app: AppContext, found: Action[], keyword: string): 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): Action[];
+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): Action[];
+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): Action[];
+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