@dineug/erd-editor 4.0.0 → 4.2.0

package/dist/components/explorer/explorer-panel/ExplorerPanel.styles.d.ts

@@ -0,0 +1,13 @@
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const header: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const title: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const tool: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const body: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const sash: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const rowIcon: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const name: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const muted: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const count: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const dot: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const mark: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=ExplorerPanel.styles.d.ts.map

package/dist/components/explorer/explorer-search/ExplorerSearch.d.ts

@@ -0,0 +1,12 @@
+import { FC } from '@dineug/r-html';
+export type ExplorerSearchProps = {
+    readonly: boolean;
+};
+/**
+ * The Explorer's search above its tree: the find field and its options, the
+ * Replace row folded away to begin with, the place in the matches with the
+ * steps through them, and the kinds of text searched past the three dots.
+ */
+declare const ExplorerSearch: FC<ExplorerSearchProps>;
+export default ExplorerSearch;
+//# sourceMappingURL=ExplorerSearch.d.ts.map

package/dist/components/explorer/explorer-search/ExplorerSearch.styles.d.ts

@@ -0,0 +1,13 @@
+export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const fields: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const rows: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const row: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const field: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const input: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const toggle: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const twisty: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const status: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const count: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const scopes: import('@dineug/r-html').CSSTemplateLiterals;
+export declare const scope: import('@dineug/r-html').CSSTemplateLiterals;
+//# sourceMappingURL=ExplorerSearch.styles.d.ts.map

package/dist/components/explorer/explorerCommands.d.ts

@@ -0,0 +1,28 @@
+import { RxStore } from '../../engine/rx-store';
+import { Emitter } from '../../utils/emitter';
+/**
+ * Whether the toolbar shows the Explorer's button pressed: open on the ERD
+ * tab and not hidden by zen mode. A panel the canvas width hides for now
+ * still counts, so a press there closes it.
+ */
+export declare function isExplorerPressed(store: RxStore): boolean;
+/** Whether the panel is drawn now, as opposed to open but stood aside. */
+export declare const isExplorerShown: (store: RxStore) => boolean;
+/**
+ * Opens the Explorer on the ERD tab, from whichever tab is up. Under zen mode
+ * it shows the panel and leaves zen on (an owner decision of 2026-10-13).
+ * Under a takeover it does nothing.
+ */
+export declare function openExplorer(store: RxStore): void;
+export declare function closeExplorer(store: RxStore): void;
+/** The toolbar button: closes a pressed button's panel, opens any other, and does nothing under a takeover. */
+export declare function toggleExplorer(store: RxStore): void;
+/**
+ * The palette's and the context menu's Toggle Explorer, which do what the find
+ * chord does: close a pressed button's panel, or ask for the search otherwise.
+ * Under a takeover it does nothing.
+ */
+export declare function toggleExplorerSearch(store: RxStore, emitter: Emitter): void;
+/** Sets the width a drag on the edge asks for, held between the least and the most. */
+export declare function setExplorerWidth(store: RxStore, width: number): void;
+//# sourceMappingURL=explorerCommands.d.ts.map

package/dist/components/explorer/explorerNavigation.d.ts

@@ -0,0 +1,14 @@
+import { ErdTarget } from '../erd/goToErdTarget';
+import { RxStore } from '../../engine/rx-store';
+import { ExplorerNode } from './explorerTree';
+/** Where on the canvas a row goes: none for a folder, which only folds and unfolds. */
+export declare function targetOf(node: ExplorerNode): ErdTarget | null;
+/**
+ * Goes to a row's or a match's target by the one jump rule, and lights a
+ * foreign key's relationship once there. Table Properties gives way first, so
+ * nothing is left under it (an owner decision of 2026-10-13).
+ */
+export declare function jumpTo(store: RxStore, target: ErdTarget): void;
+/** Goes where a row stands for; a folder goes nowhere. */
+export declare function activateNode(store: RxStore, node: ExplorerNode): void;
+//# sourceMappingURL=explorerNavigation.d.ts.map

package/dist/components/explorer/explorerSearch.d.ts

@@ -0,0 +1,71 @@
+import { AnyAction } from '@dineug/r-html';
+import { RxStore } from '../../engine/rx-store';
+import { I18n } from '../../i18n/translate';
+import { Emitter } from '../../utils/emitter';
+import { FindField, FindMatch, Matcher, ReplaceRun } from '../../utils/find-replace';
+/** How long typing must pause before a regular expression is searched, as one can be slow. */
+export declare const REGEX_INPUT_DELAY = 150;
+/** What the search holds that no render reads: the matcher, the run, the timers. */
+type SearchRuntime = {
+    matcher: Matcher | null;
+    pendingSearch: ReturnType<typeof setTimeout> | null;
+    /** Set while the search dispatches its own edit, whose matches it has worked out already. */
+    replacing: boolean;
+    /** Set by an edit of a searched text the tree does not show yet, one made while it stood aside say. */
+    stale: boolean;
+    /** Where the presses of Replace since the last jump or change of search began. */
+    run: ReplaceRun | null;
+    /** Set once that run has come back to where it began, which holds until a new run. */
+    stopped: boolean;
+    /** The last focus request the find field took or let go. */
+    focusTaken: number;
+};
+export declare function searchRuntimeOf(store: RxStore): SearchRuntime;
+/** Whether a query is being searched, which puts the tree in its search form. */
+export declare const isSearching: (store: RxStore) => boolean;
+/** What the line under the fields says: the place in the matches, how many there are, or why none. */
+export declare function countText(store: RxStore, i18n: Pick<I18n, 't'>): string;
+/** Drops a regular expression's search still waiting for typing to pause. */
+export declare function cancelPendingSearch(store: RxStore): void;
+/** Whether the find field may take the keyboard now, which it marks as taken. */
+export declare function takeSearchFocus(store: RxStore): boolean;
+/** Whether a dialog the search trades for itself is up, which the chord then trades. */
+export declare const hasSearchDialog: (store: RxStore) => boolean;
+/**
+ * Brings the keyboard back to the search of a panel shown already, keeping
+ * its current match and its run, as every host's find does pressed again.
+ */
+export declare function focusSearch(store: RxStore): void;
+/**
+ * Opens the Explorer on its search, handing it the keyboard. A canvas too
+ * narrow says so rather than show nothing (an owner decision of 2026-10-13).
+ */
+export declare function openSearch(store: RxStore, emitter: Emitter): void;
+export declare function goToNext(store: RxStore): void;
+export declare function goToPrevious(store: RxStore): void;
+/** A row picked before a regular expression's pause goes to its match among those of what is typed, if any. */
+export declare function goToMatch(store: RxStore, match: FindMatch): void;
+/**
+ * Replaces the current match and takes the canvas to the next one in the same
+ * dispatch, so one undo takes back both. A run that comes back to where it
+ * began stops there rather than go round to what it wrote.
+ */
+export declare function replaceOne(store: RxStore): void;
+/** Replaces every match in one dispatch: one history entry and one batch to every peer. */
+export declare function replaceAll(store: RxStore): void;
+/** Searches plain text at once, as it is quick, and a regular expression once typing pauses. */
+export declare function setQuery(store: RxStore, query: string): void;
+export declare function setReplacement(store: RxStore, replacement: string): void;
+/** Match Case, Whole Word and Regex search again; Preserve Case only shapes what Replace writes. */
+export declare function toggleOption(store: RxStore, key: 'matchCase' | 'wholeWord' | 'regex' | 'preserveCase'): void;
+export declare function toggleField(store: RxStore, field: FindField): void;
+/**
+ * An edit of a searched text leaves the matches stale: searched again once
+ * the edits pause while the panel is shown, or at once by the batch that shows
+ * it again. A hover, a selection or a scroll edits none and searches nothing.
+ */
+export declare function noteBatch(store: RxStore, actions: AnyAction[]): boolean;
+/** Searches again when an edit left the matches stale and the search is on screen. */
+export declare function searchIfStale(store: RxStore): void;
+export {};
+//# sourceMappingURL=explorerSearch.d.ts.map

package/dist/components/explorer/explorerTree.d.ts

@@ -0,0 +1,93 @@
+import { TreeNode } from '../primitives/tree/treeModel';
+import { RootState } from '../../engine/state';
+import { FindMatch } from '../../utils/find-replace';
+export type ExplorerFolder = 'tables' | 'tableGroups' | 'memos' | 'columns' | 'indexes' | 'foreignKeys';
+/** The matches a search found in a row's own name, which it marks; none outside a search. */
+type NameMatches = {
+    matches?: ReadonlyArray<FindMatch>;
+};
+/** What one row of the Explorer stands for, and what it shows of it. */
+export type ExplorerNode = {
+    kind: 'folder';
+    folder: ExplorerFolder;
+    count: number;
+} | ({
+    kind: 'table';
+    tableId: string;
+    name: string;
+    logicalName: string;
+} & NameMatches) | ({
+    kind: 'column';
+    tableId: string;
+    columnId: string;
+    name: string;
+    logicalName: string;
+    dataType: string;
+    primaryKey: boolean;
+    foreignKey: boolean;
+} & NameMatches) | ({
+    kind: 'index';
+    tableId: string;
+    indexId: string;
+    name: string;
+    unique: boolean;
+    columns: string;
+} & NameMatches) | {
+    kind: 'foreignKey';
+    relationshipId: string;
+    tableId: string;
+    /** Whether its columns key the child too, which the connector draws in the PK and FK colour. */
+    identification: boolean;
+    columns: string;
+    parent: string;
+    parentColumns: string;
+} | ({
+    kind: 'tableGroup';
+    tableGroupId: string;
+    name: string;
+    color: string;
+} & NameMatches) | {
+    kind: 'groupTable';
+    tableGroupId: string;
+    tableId: string;
+    name: string;
+    logicalName: string;
+} | {
+    kind: 'memo';
+    memoId: string;
+    text: string;
+}
+/** One match in a comment or a memo, shown as the stretch of text around it. */
+ | {
+    kind: 'excerpt';
+    match: FindMatch;
+};
+export type ExplorerTreeNode = TreeNode<ExplorerNode>;
+/**
+ * The Explorer's folders, Tables, Table Groups and Memos, each only while it
+ * holds something and groups and memos only while shown. Tables and groups go
+ * by name, memos as the document has them; a table's folders wait for its expanding.
+ */
+export declare function buildExplorerTree(state: RootState): ExplorerTreeNode[];
+/**
+ * The row a match shows on in the search's tree: a name's own row, or the
+ * excerpt row of a comment or memo, one for each match there.
+ */
+export declare function matchRowId(match: FindMatch): string;
+/** The rows above a match's row in the search's tree, which must be open for the row to be drawn. */
+export declare function matchAncestorIds(match: FindMatch): string[];
+export type SearchTree = {
+    roots: ExplorerTreeNode[];
+    /** Every row with children, which a search shows open unless folded. */
+    branchIds: string[];
+};
+/**
+ * The tree a search shows: the rows that hold a match and the rows above
+ * them, in the order the search walked, with a comment's or memo's matches as
+ * rows of their own. A group's tables are left out, found under Tables alone.
+ */
+export declare function buildSearchTree(state: RootState, matches: ReadonlyArray<FindMatch>): SearchTree;
+/** What a search shows open: every row with children but those folded. */
+export declare function searchExpanded(branchIds: ReadonlyArray<string>, collapsed: Readonly<Record<string, true>>): Record<string, true>;
+export {};
+//# sourceMappingURL=explorerTree.d.ts.map

package/dist/components/explorer/explorerView.d.ts

@@ -0,0 +1,54 @@
+import { RxStore } from '../../engine/rx-store';
+import { FieldOrder, FindField, FindMatch } from '../../utils/find-replace';
+/** The folder the tree shows open as the Explorer first opens. */
+export declare const TABLES_FOLDER_ID = "f:tables";
+export type ExplorerView = {
+    open: boolean;
+    /** Set by an opening while zen mode is on, which shows the panel without leaving zen. */
+    zenReveal: boolean;
+    width: number;
+    /** Replaced whole on every change: r-html tracks no Set, Map or frozen value. */
+    expanded: Record<string, true>;
+    /** The row the keyboard is on, kept by node id so a row added before it moves nothing. */
+    activeId: string | null;
+    query: string;
+    replacement: string;
+    matchCase: boolean;
+    wholeWord: boolean;
+    regex: boolean;
+    preserveCase: boolean;
+    /** Replaced whole on every change, a copy of the frozen default to begin with. */
+    fields: FindField[];
+    /** Whether the Replace row is unfolded, and the row of scopes past the three dots. */
+    replaceOpen: boolean;
+    scopesOpen: boolean;
+    /** The match the canvas was last taken to, by its place in the matches; -1 for none. */
+    current: number;
+    status: PressStatus | null;
+    matches: FindMatch[];
+    error: 'empty' | 'invalid' | null;
+    /** The walk's order: by name, or the one a run of Replace presses began with. */
+    order: FieldOrder | null;
+    /** The folders and rows folded while a search shows, every other one open. */
+    searchCollapsed: Record<string, true>;
+    /** Raised to ask the find field for the keyboard; dropped unless a drawn panel takes it. */
+    focusRequest: number;
+};
+/**
+ * What the last press of Replace or Replace All said, kept as what it means
+ * rather than as text, so a switch of language reads it again in the new one.
+ */
+export type PressStatus = 'noMoreMatches' | 'noChanges' | {
+    replaced: number;
+};
+/**
+ * The Explorer's own state, one per editor, kept until the element goes:
+ * never in the store, the file, the history or a peer, so it survives a tab
+ * change and a reload of the document alike.
+ */
+export declare function explorerViewOf(store: RxStore): ExplorerView;
+/** Where the tree is scrolled to, unobserved, so a scroll renders nothing outside the tree. */
+export declare function explorerScrollOf(store: RxStore): {
+    top: number;
+};
+//# sourceMappingURL=explorerView.d.ts.map

package/dist/components/{find-replace → explorer}/fieldIcon.d.ts

@@ -1,5 +1,8 @@
 import { DOMTemplateLiterals } from '@dineug/r-html';
 import { FindField } from '../../utils/find-replace';
-/** The icon a result row carries for the kind of text it was found in. */
+/**
+ * The icon a result row carries for the kind of text it was found in. A
+ * logical name draws a column's, since only the column search lists one.
+ */
 export declare function fieldIcon(field: FindField, size?: number): DOMTemplateLiterals;
 //# sourceMappingURL=fieldIcon.d.ts.map

package/dist/components/{find-replace → explorer}/matchTarget.d.ts

@@ -4,23 +4,21 @@ import { GeneratorAction } from '../../engine/generator.actions';
 import { RootState } from '../../engine/state';
 import { FindMatch } from '../../utils/find-replace';
 /**
- * Where on the ERD canvas the text of a match is edited: its table, its column
- * cell or its memo, with the match itself, which a cell too wide for the
- * canvas is scrolled to by.
+ * Where on the ERD canvas a match's text is edited: its table, column cell,
+ * memo or table group, with the match, which a cell too wide is scrolled to
+ * by. An index goes to its table, a logical name to the cell the view draws.
  */
 export declare function toErdTarget(match: FindMatch): ErdTarget;
 /**
  * The state as a jump measures it once a replacement is in: the field holding
- * the new text at the width its reducer gives it. A memo's text sizes nothing,
- * and a table or column the document no longer holds is left as it is.
+ * the new text at the width its reducer gives it, a name a logical name derives
+ * left as it was. A memo, an index or a group name sizes no table.
  */
-export declare function withReplacement(state: RootState, { toWidth }: EngineContext, { field, id, tableId }: FindMatch, value: string): RootState;
+export declare function withReplacement(state: RootState, { toWidth }: EngineContext, match: FindMatch, value: string): RootState;
 /**
  * The jump Replace makes to the next match, in the replacement's own dispatch.
  * A batch is read against the state before it, so the jump measures the table
  * the replacement widens or narrows from what the replacement writes.
- *
- * @param covered How far in from the left edge the panel hides the canvas.
  */
-export declare const showNextMatchAction$: (next: FindMatch, replaced: FindMatch, value: string, covered: number) => GeneratorAction;
+export declare const showNextMatchAction$: (next: FindMatch, replaced: FindMatch, value: string) => GeneratorAction;
 //# sourceMappingURL=matchTarget.d.ts.map

package/dist/components/export-image/ExportImage.d.ts

@@ -1,4 +1,5 @@
 import { FC } from '@dineug/r-html';
+import { RootState } from '../../engine/state';
 import { ThemeOptions } from '../../themes/radix-ui-theme';
 export type ExportImageProps = {
     /** The gray and accent the editor's preset is built from. */
@@ -13,6 +14,15 @@ export type ExportScale = (typeof EXPORT_SCALES)[number];
 export declare const PREVIEW_MAX_SIDE = 1280;
 /** How long the toggles rest before the preview is drawn again. */
 export declare const PREVIEW_DEBOUNCE_MS = 200;
+/**
+ * The document an image is drawn from: the words and terms left out, which
+ * only the checks read and an image marks none of, and the domains kept,
+ * whose names the logical view's type cells draw.
+ *
+ * @example
+ * const doc = toExportJson(store.state);
+ */
+export declare const toExportJson: (state: RootState) => string;
 /**
  * The export image dialog: a preview, the options, the buttons that write a png
  * or an svg or copy a png, and a close button. The options last for the

package/dist/components/export-image/exportImageActions.d.ts

@@ -32,9 +32,9 @@ export declare function exportImagePng({ emitter }: AppContext, request: ImageRe
  * a failure is reported once the file is done.
  *
  * @example
- * await exportImageSvg(app, { doc, theme, toWidth, i18n }, databaseName);
+ * await exportImageSvg(app, { doc, theme, toWidth, i18n, nameViewMode }, databaseName);
  */
-export declare function exportImageSvg({ emitter }: AppContext, { doc, theme, toWidth, i18n }: SvgRequest, databaseName: string): Promise<void>;
+export declare function exportImageSvg({ emitter }: AppContext, { doc, theme, toWidth, i18n, nameViewMode }: SvgRequest, databaseName: string): Promise<void>;
 /**
  * Puts the document on the clipboard as a png. The clipboard write starts in
  * the click that called this, before any await, so call it from the handler

package/dist/components/flowCenters.d.ts

@@ -1,4 +1,5 @@
 import { AppContext } from './appContext';
+import { CenterStep } from '../engine/modules/editor/state';
 /**
  * Narrows the Flow view to the tables given and their one hop. State alone:
  * the placement loop reads the display set it names and asks for the layout,
@@ -7,4 +8,12 @@ import { AppContext } from './appContext';
 export declare function focusFlowView(app: AppContext, tableIds: string[]): void;
 /** Widens the Flow view back to everything it placed, through that same one channel: state alone. */
 export declare function showAllFlowView(app: AppContext): void;
+/**
+ * Stands the Flow view on the centers a step the way given reaches, through that
+ * same one channel: state alone. With nowhere to go it dispatches nothing, so a
+ * dimmed button or a chord pressed again wakes no sort and drops no set.
+ */
+export declare function stepFlowView(app: AppContext, step: CenterStep): void;
+/** Whether a step the way given would move the Flow view, past the sets it would pass over. */
+export declare function canStepFlowView(app: AppContext, step: CenterStep): boolean;
 //# sourceMappingURL=flowCenters.d.ts.map

package/dist/components/map-columns/nameOf.d.ts

@@ -1,6 +1,14 @@
+import { RootState } from '../../engine/state';
 import { I18n } from '../../i18n/translate';
-/** A table's or column's name as Map Columns and the draw-target buttons write it, unnamed where it has none. */
-export declare const nameOf: (entity: {
+type ViewSettings = Pick<RootState['settings'], 'nameViewMode'>;
+/**
+ * A table's or column's name as Map Columns, the draw-target buttons and the
+ * check sheet write it: the one the name view shows, the name after the
+ * logical name in the view of both, and unnamed where it shows none.
+ */
+export declare function nameOf(entity: {
     name: string;
-} | undefined, { t }: Pick<I18n, "t">) => string;
+    logicalName: string;
+} | undefined, { t }: Pick<I18n, 't'>, settings: ViewSettings): string;
+export {};
 //# sourceMappingURL=nameOf.d.ts.map

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

@@ -9,26 +9,31 @@ declare const LUCIDE_ICON: {
     'arrow-right': IconNode;
     'arrow-up': IconNode;
     atom: IconNode;
+    'book-type': 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;
+    'funnel-x': IconNode;
     'grip-vertical': IconNode;
     group: IconNode;
     hand: IconNode;
@@ -36,9 +41,14 @@ declare const LUCIDE_ICON: {
     'key-round': IconNode;
     languages: IconNode;
     link: IconNode;
+    list: IconNode;
+    'list-plus': IconNode;
+    'list-tree': IconNode;
+    'list-x': IconNode;
     'loader-circle': IconNode;
     lock: IconNode;
     'lock-open': IconNode;
+    logs: IconNode;
     maximize: IconNode;
     'message-square': IconNode;
     minimize: IconNode;
@@ -62,17 +72,16 @@ declare const LUCIDE_ICON: {
     'rotate-ccw-clock': IconNode;
     search: IconNode;
     settings: IconNode;
-    'settings-2': IconNode;
     'share-2': IconNode;
     spline: IconNode;
     'sticky-note': IconNode;
     sun: IconNode;
     'table-2': IconNode;
     'table-properties': IconNode;
-    'text-search': IconNode;
     'triangle-alert': IconNode;
     'undo-2': IconNode;
     ungroup: IconNode;
+    upload: 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/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.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

@@ -5,7 +5,6 @@ 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;
@@ -14,6 +13,8 @@ export type Action = {
     shortcut?: string;
     /** The table a row jumps to, whose keyword names the kind of row, not the table. */
     tableId?: string;
+    /** A table row's own names, its name and logical name, which a search reads whatever the name view shows. */
+    tableNames?: 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. */
@@ -65,9 +66,7 @@ export declare function createScopeActions(app: AppContext, i18n?: I18n, prefere
 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. */
+/** The six 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/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