@dineug/erd-editor 3.10.0 → 4.0.0

package/dist/components/primitives/color-picker/colorModel.d.ts

@@ -0,0 +1,36 @@
+/** Hue in degrees 0 to 360, saturation and value 0 to 1, kept unrounded. */
+export type Hsv = {
+    h: number;
+    s: number;
+    v: number;
+};
+export type Rgb = [number, number, number];
+/** The channels of a color, rounded to whole 0 to 255 values; a hue of 360 is red again. */
+export declare function hsvToRgb({ h, s, v }: Hsv): Rgb;
+/**
+ * A color's hue, saturation and value, kept from the one before where the
+ * channels hold none: a gray keeps the hue it had, and black keeps both.
+ */
+export declare function rgbToHsv([r, g, b]: Rgb, previous: Hsv): Hsv;
+/** A color as the lower-case #rrggbb it is handed on as. */
+export declare function hsvToHex(hsv: Hsv): string;
+/** A #rrggbb as hue, saturation and value, keeping what it lacks from the one before. */
+export declare function hexToHsv(hex: string, previous: Hsv): Hsv;
+/**
+ * What the Hex field reads as a color: digits with or without the mark, 3, 4,
+ * 6 or 8 of them, or a pasted rgb() or hsl(), any alpha dropped; else null.
+ */
+export declare function parseHexInput(text: string): string | null;
+/** Whether the Hex field holds a whole color already, which it applies while typed. */
+export declare function isCompleteHexInput(text: string): boolean;
+/** A channel field's whole number, 255 at most; null for anything else. */
+export declare function parseChannelInput(text: string): number | null;
+/**
+ * Where a key moves the saturation and brightness area, from the whole
+ * percent nearest: left and right move saturation, the rest brightness, Home
+ * and End take saturation to either end; null for a key it does not take.
+ */
+export declare function stepArea(hsv: Hsv, key: string, coarse: boolean): Hsv | null;
+/** Where a key moves the hue, from the whole degree nearest, held to 0 to 360; null for a key it does not take. */
+export declare function stepHue(h: number, key: string, coarse: boolean): number | null;
+//# sourceMappingURL=colorModel.d.ts.map

package/dist/components/primitives/color-picker/presetColors.d.ts

@@ -0,0 +1,13 @@
+import { PlainMessageKey } from '../../../i18n/translate';
+export type ColorSwatch = {
+    color: string;
+    label: string;
+};
+/** A preset swatch, named by the key of its hue's name, which a screen reader hears in the reader's language. */
+export type PresetSwatch = {
+    color: string;
+    labelKey: PlainMessageKey;
+};
+/** Sixteen Radix step 9 colors, two rows of eight, in their light values, which a document keeps whatever the theme. */
+export declare const PRESET_COLORS: ReadonlyArray<PresetSwatch>;
+//# sourceMappingURL=presetColors.d.ts.map

package/dist/components/primitives/color-picker/resolveColor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A CSS color as an opaque lower-case #rrggbb, any alpha dropped: the forms toOpaqueHex
+ * reads, then any a canvas fillStyle reads, a name such as red or an oklch(); null for
+ * an empty or unreadable one, or one in the canvas's own syntax that paints nothing.
+ */
+export declare function resolveColor(color: string): string | null;
+//# sourceMappingURL=resolveColor.d.ts.map

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

@@ -1,9 +1,11 @@
 import { default as ContextMenuItem } from './context-menu-item/ContextMenuItem';
 import { default as ContextMenuRoot } from './context-menu-root/ContextMenuRoot';
+import { default as ContextMenuSeparator } from './context-menu-separator/ContextMenuSeparator';
 import { default as Menu } from './menu/Menu';
 type CompositionContextMenu = {
     Root: typeof ContextMenuRoot;
     Item: typeof ContextMenuItem;
+    Separator: typeof ContextMenuSeparator;
     Menu: typeof Menu;
 };
 declare const ContextMenu: CompositionContextMenu;

package/dist/components/primitives/context-menu/context-menu-content/ContextMenuContent.d.ts

@@ -5,6 +5,7 @@ export type ContextMenuContentProps = {
     y: number;
     fit?: boolean;
     flipX?: number;
+    openLeft?: boolean;
     children?: DOMTemplateLiterals;
 };
 declare const ContextMenuContent: FC<ContextMenuContentProps>;

package/dist/components/primitives/context-menu/context-menu-content/fitMenu.d.ts

@@ -9,11 +9,11 @@ export type WindowSize = {
     height: number;
 };
 /**
- * How far a menu drawn at box moves into the window: back from the right and
- * bottom edges, never past the left and top. A submenu the right edge cuts
- * flips to end at flipRight instead, unless the left edge would cut it more.
+ * How far a menu drawn at box moves into the window, never past its left and
+ * top. A submenu opens right of its row, or left to end at flipRight for a
+ * right-to-left reader, and switches only when its side cuts it more.
  */
-export declare function fitMenu(box: MenuBox, view: WindowSize, flipRight?: number): {
+export declare function fitMenu(box: MenuBox, view: WindowSize, flipRight?: number, openLeft?: boolean): {
     dx: number;
     dy: number;
 };

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,6 +5,7 @@ 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;
@@ -20,6 +21,7 @@ declare const LUCIDE_ICON: {
     copy: IconNode;
     database: IconNode;
     diff: IconNode;
+    download: IconNode;
     'external-link': IconNode;
     eye: IconNode;
     'file-diff': IconNode;
@@ -28,17 +30,29 @@ declare const LUCIDE_ICON: {
     'file-output': IconNode;
     fullscreen: IconNode;
     'grip-vertical': IconNode;
+    group: IconNode;
     hand: IconNode;
+    keyboard: IconNode;
     'key-round': IconNode;
+    languages: IconNode;
+    link: IconNode;
+    'loader-circle': IconNode;
     lock: IconNode;
+    'lock-open': 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;
@@ -48,6 +62,7 @@ declare const LUCIDE_ICON: {
     'rotate-ccw-clock': IconNode;
     search: IconNode;
     settings: IconNode;
+    'settings-2': IconNode;
     'share-2': IconNode;
     spline: IconNode;
     'sticky-note': IconNode;
@@ -55,7 +70,9 @@ declare const LUCIDE_ICON: {
     '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/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/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/actions.d.ts

@@ -1,6 +1,10 @@
 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 = {
@@ -12,10 +16,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 +46,28 @@ 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;
+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): Action;
-export declare const allScopeActions: Action[];
+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

@@ -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/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,4 +1,5 @@
 import { AppContext } from '../appContext';
+import { I18n } from '../../i18n/translate';
 import { FindField } from '../../utils/find-replace';
 import { Action } from './actions';
 import { PaletteQuery, PaletteScope } from './paletteQuery';
@@ -17,25 +18,25 @@ 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, 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): Action[];
+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): 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

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