@dineug/erd-editor 4.0.0 → 4.1.0

package/dist/components/erd/diff-viewer/diff.d.ts

@@ -1,27 +1,29 @@
-import { RootState } from '../../../engine/state';
-import { Column, Table } from '../../../internal-types';
 import { Theme } from '../../../themes/tokens';
-/**
- * Map<uuid, [tag, Map<path, diff>]>
- */
-export type DiffMap = Map<string, DiffTuple>;
-/** Map<path, diff> for one entity, each path spelled as the FocusType of the cell showing it. */
-export type DiffPaths = Map<string, number>;
-type DiffTuple = [string, DiffPaths];
-type NameToTableMap = Map<string, {
-    table: Table;
-    nameToColumnMap: Map<string, Column>;
-}>;
+/** The kinds of change a diff pane marks, one bit each. */
 export declare const Diff: {
     readonly insert: 1;
     readonly delete: 2;
+    readonly modify: 4;
+    readonly rename: 8;
 };
-export declare function diffState(prevState: RootState, state: RootState): [DiffMap, DiffMap];
-export declare function getNameToTableMap({ doc: { tableIds }, collections, }: RootState): NameToTableMap;
 /**
- * The background a cell of one entity sits on in a diff pane: the insert or the
- * delete colour its own path carries, and null for a path that did not change.
+ * Map<path, diff> for one entity: a cell's path is the FocusType of the cell
+ * showing it, and ENTITY_PATH stands for the entity as a whole.
+ */
+export type DiffPaths = Map<string, number>;
+/** Map<id, paths> for the entities one pane marks. */
+export type DiffMap = Map<string, DiffPaths>;
+/** An entity added or removed, or one only moved, resized, recoloured or regrouped. */
+export declare const ENTITY_PATH = "entity";
+export declare const MEMO_VALUE_PATH = "memoValue";
+/** A column's primary key, which its key icon shows. */
+export declare const COLUMN_KEY_PATH = "columnPrimaryKey";
+export declare const TABLE_GROUP_NAME_PATH = "tableGroupName";
+/**
+ * The colour a cell's text takes in a diff pane: its own change's, else, in a
+ * row, the row's as a whole; null where neither changed.
  */
-export declare function diffFill(theme: Theme, paths: DiffPaths | null | undefined, path: string): string | null;
-export {};
+export declare function diffTextColor(theme: Theme, paths: DiffPaths | null | undefined, path: string, row?: boolean): string | null;
+/** The outline an entity takes in a diff pane, or the colour of a line; null for none. */
+export declare function diffOutline(theme: Theme, paths: DiffPaths | null | undefined): string | null;
 //# sourceMappingURL=diff.d.ts.map

package/dist/components/erd/draw-target/placePill.d.ts

@@ -18,8 +18,6 @@ export type PlacePillInput = {
     /** The table's box on screen. */
     card: Rect;
     viewport: Viewport;
-    /** How far in from the left edge Find and Replace hides the canvas. */
-    covered: number;
     /** The chrome drawn over the canvas that the buttons keep clear of. */
     obstacles: readonly Rect[];
     pill: PillSize;
@@ -34,7 +32,7 @@ export declare function getVisibleSpan(card: Rect, viewport: Viewport): {
  * top of its shown part and inside the canvas. Off the minimap and the floating
  * toolbar by moving below or above it, then by the other side, else put.
  */
-export declare function placePill({ card, viewport, covered, obstacles, pill, }: PlacePillInput): PillPlacement;
+export declare function placePill({ card, viewport, obstacles, pill, }: PlacePillInput): PillPlacement;
 /**
  * The clear strip from a little past the buttons to the table, as tall as both,
  * which takes a press that would reach a neighbour or the start table under it,

package/dist/components/erd/floating-toolbar/FloatingToolbar.d.ts

@@ -1,9 +1,12 @@
 import { FC } from '@dineug/r-html';
-export type FloatingToolbarProps = {};
+export type FloatingToolbarProps = {
+    /** The editor's readonly, under which the bar offers nothing to add. */
+    readonly?: boolean;
+};
 /**
- * The bar over the bottom of the canvas: which of the two a press means, the
- * zoom, the notation the next relationship is drawn in, zen mode, and which
- * way the content lies once the screen holds none. It is the one surface zen mode leaves standing.
+ * The bar over the bottom of the canvas: which of the two a press means, what
+ * to add, the zoom, the notation the next relationship is drawn in, zen mode,
+ * and which way the content lies once the screen holds none. It is the one surface zen mode leaves standing.
  */
 declare const FloatingToolbar: FC<FloatingToolbarProps>;
 export default FloatingToolbar;

package/dist/components/erd/goToErdTarget.d.ts

@@ -10,7 +10,7 @@ export type TextRange = {
     start: number;
     end: number;
 };
-/** What a jump to the ERD lands on: a table, one cell of a column, or a memo. */
+/** What a jump to the ERD lands on: a table, one cell of a column, a memo, a relationship or a table group. */
 export type ErdTarget = {
     kind: 'table';
     tableId: string;
@@ -25,19 +25,42 @@ export type ErdTarget = {
 } | {
     kind: 'memo';
     memoId: string;
+} | {
+    kind: 'relationship';
+    relationshipId: string;
+} | {
+    kind: 'tableGroup';
+    tableGroupId: string;
 };
-type Span = {
+/** How far in from the edge of the screen a jump keeps what it shows of a rect too long for it. */
+export declare const EDGE_MARGIN = 40;
+export type Span = {
     start: number;
     end: number;
 };
 /**
- * The scroll that puts the rect in the middle of what the screen shows at the
- * document's own zoom, unless it is shown whole already, since that scroll is
- * the one change of a jump the host hears of.
+ * The one jump rule every go-to shares: each axis judged on its own, the one
+ * that is fine left where it is. Where the rect would start on screen, or null
+ * when neither start moves by more than half a pixel, as on a press repeated.
+ *
+ * @example
+ * planJump({ width: 800, height: 600 }, toScreenSpans(state, rect), focusSpans);
+ */
+export declare function planJump(viewport: {
+    width: number;
+    height: number;
+}, [rectX, rectY]: [Span, Span], [focusX, focusY]: [Span, Span]): {
+    x: number;
+    y: number;
+} | null;
+/**
+ * The scroll the jump rule asks for to bring the rect into view at the
+ * document's own zoom, none when it asks for none, since that scroll is the
+ * one change of a jump the host hears of.
  *
  * @param focus The part of a rect too big for the screen that has to show.
  */
-export declare function scrollIntoView(state: RootState, rect: Rect, covered?: number, focus?: Rect): Generator<import('@dineug/r-html').AnyAction<{
+export declare function scrollIntoView(state: RootState, rect: Rect, focus?: Rect): Generator<import('@dineug/r-html').AnyAction<{
     originX: number;
     originY: number;
 }>, void, unknown>;
@@ -48,7 +71,7 @@ export declare function scrollIntoView(state: RootState, rect: Rect, covered?: n
  *
  * @param range Where the text a jump is for stands in that cell, in from its left edge.
  */
-export declare function scrollTableIntoView(state: RootState, table: Table, covered?: number, focusType?: FocusType, range?: Span): Generator<import('@dineug/r-html').AnyAction<{
+export declare function scrollTableIntoView(state: RootState, table: Table, focusType?: FocusType, range?: Span): Generator<import('@dineug/r-html').AnyAction<{
     originX: number;
     originY: number;
 }>, void, unknown>;
@@ -59,13 +82,16 @@ export declare function scrollTableIntoView(state: RootState, table: Table, cove
  */
 export declare const selectTableAloneAction$: (tableId: string) => GeneratorAction;
 /**
- * Stands the reader on a table, a column cell or a memo the way the Go to ERD
- * button stands them on a table, with the focus ring on the cell asked for. A
- * row too wide goes by the ringed cell, a cell too wide by the range found.
- *
- * @param covered How far in from the left edge a panel over the canvas hides it.
+ * Whether a jump to the relationship shows it, as showErdTargetAction$ does
+ * only while it and both its tables stand; a host lights none it did not show.
+ */
+export declare function isRelationshipShown(state: RootState, relationshipId: string): boolean;
+/**
+ * Stands the reader on a table, a column cell, a memo, a relationship or a
+ * table group by the one jump rule, with the focus ring on the cell asked for.
+ * A row too wide goes by the ringed cell, a cell too wide by the range found.
  */
-export declare const showErdTargetAction$: (target: ErdTarget, covered?: number) => GeneratorAction;
+export declare const showErdTargetAction$: (target: ErdTarget) => GeneratorAction;
 /**
  * Takes the ERD tab when another is up, in a dispatch of its own: a batch is
  * classified by the state before it, so a scroll travelling with the tab
@@ -74,12 +100,10 @@ export declare const showErdTargetAction$: (target: ErdTarget, covered?: number)
 export declare function showErdTab(store: RxStore): void;
 /**
  * A jump from outside the canvas, a search result say, to anything it holds,
- * from whichever tab is up. It lands clear of the Find and Replace panel, read
- * once the ERD tab is up, so a panel that tab draws again counts too.
+ * from whichever tab is up, measured on the canvas once the ERD tab is up.
  *
  * @example
  * goToErdTarget(store, { kind: 'memo', memoId: 'note' });
  */
 export declare function goToErdTarget(store: RxStore, target: ErdTarget): void;
-export {};
 //# sourceMappingURL=goToErdTarget.d.ts.map

package/dist/components/erd/relationshipHighlight.d.ts

@@ -0,0 +1,18 @@
+/** Lights one relationship in the editor, and puts out the one it lit before. */
+export declare function setRelationshipHighlight(editorId: string, relationshipId: string): void;
+/** Puts out whatever relationship the editor has lit. */
+export declare function clearRelationshipHighlight(editorId: string): void;
+/** Whether a jump has lit the relationship, read by its connector as it reads a hover. */
+export declare function isRelationshipHighlighted(editorId: string, relationshipId: string): boolean;
+/** Forgets an editor that went, whose id nothing reads again. */
+export declare function dropRelationshipHighlight(editorId: string): void;
+/**
+ * Test-only probe: the flags the reactive record holds and the editors it
+ * remembers, which a read of an editor never lit must not grow. Nothing
+ * shipping calls it.
+ */
+export declare function countRelationshipHighlights(): {
+    flags: number;
+    editors: number;
+};
+//# sourceMappingURL=relationshipHighlight.d.ts.map

package/dist/components/erd/welcome-screen/welcome-hints/WelcomeHints.styles.d.ts

@@ -4,6 +4,11 @@
  * stands across the canvas is set inline, from the button it was measured at.
  */
 export declare const up: import('@dineug/r-html').CSSTemplateLiterals;
+/**
+ * A hint whose label has no room beside its arrow: the label hangs under the
+ * arrow's tail, clear of a label beside the next arrow.
+ */
+export declare const stacked: import('@dineug/r-html').CSSTemplateLiterals;
 /**
  * The hint over the floating toolbar, centred over it as the toolbar is, its
  * arrow's tip clear of the bar's top edge.

package/dist/components/erd/welcome-screen/welcomeLayout.d.ts

@@ -16,6 +16,8 @@ export declare const WELCOME_MENU_MIN_HEIGHT = 294;
  */
 export declare const WELCOME_HINTS_MIN_WIDTH = 720;
 export declare const WELCOME_HINTS_MIN_HEIGHT = 562;
+/** The widest a hint's label runs before it wraps, as WelcomeHints.styles.ts sets it. */
+export declare const HINT_LABEL_MAX_WIDTH = 220;
 /** The narrowest canvas whose menu rows still show their chords. */
 export declare const WELCOME_KBD_MIN_WIDTH = 480;
 /** The arrow that climbs to a toolbar button: its box, and its tip near the top right. */
@@ -75,13 +77,15 @@ export type HintSide = 'before' | 'after';
  */
 export type HintPlacement = {
     labelFirst: boolean;
+    /** The label hangs under the arrow's tail, as the side it names has no room for it. */
+    stacked: boolean;
     left?: number;
     right?: number;
 };
 /**
- * Places a hint so the tip of its arrow meets the anchor, the label on the
- * side it names: before is left in a left-to-right language and right in a
- * right-to-left one, so the hints mirror with the toolbar they point at.
+ * Places a hint so its arrow's tip meets the anchor, the label on the side it
+ * names (before: left to right, left; right to left, right), or under the
+ * arrow where that side has no room for a whole label, as beside the Explorer.
  */
 export declare function hintPlacement(anchorX: number, rootWidth: number, side: HintSide, dir: TextDirection): HintPlacement;
 //# sourceMappingURL=welcomeLayout.d.ts.map

package/dist/components/erd-editor/ErdEditor.styles.d.ts

@@ -1,3 +1,7 @@
 export declare const root: import('@dineug/r-html').CSSTemplateLiterals;
 export declare const scope: import('@dineug/r-html').CSSTemplateLiterals;
+/** The ERD tab's row: the Explorer, when shown, and the canvas beside it. */
+export declare const erdRow: import('@dineug/r-html').CSSTemplateLiterals;
+/** The canvas's share of the row, all of it the Explorer leaves. */
+export declare const erdScope: import('@dineug/r-html').CSSTemplateLiterals;
 //# sourceMappingURL=ErdEditor.styles.d.ts.map

package/dist/components/erd-editor/viewportLayout.d.ts

@@ -0,0 +1,52 @@
+import { RxStore } from '../../engine/rx-store';
+import { RootState } from '../../engine/state';
+import { Unsubscribe } from '../../internal-types';
+export type Layout = {
+    /** The root as the ResizeObserver last measured it. */
+    observed: {
+        width: number;
+        height: number;
+    };
+    /** How much of the root's width a panel docked beside the canvas takes. */
+    reach: number;
+};
+/** The root's measured size and the panel reach, one per editor, kept until the element goes. */
+export declare function layoutOf(store: RxStore): Layout;
+/**
+ * Whether the toolbar is drawn. Zen mode takes it away over the canvas it was
+ * entered from alone, or the tab that turned the mode on would be the only one
+ * it could be turned off from.
+ */
+export declare const hasToolbar: ({ editor, settings }: RootState) => boolean;
+/**
+ * The editor's own width, panel included, which decides whether a dialog
+ * stacks: the viewport plus the reach a docked panel takes from it, so a spec
+ * that sets the viewport alone reads that width.
+ */
+export declare function editorWidthOf(store: RxStore): number;
+/**
+ * Applies the viewport from what decides it: the measured root, the toolbar
+ * zen mode takes away, the tab and the Explorer. It compares those first and
+ * returns when none moved, writes the reach first, and dispatches only a new viewport.
+ */
+export declare function applyViewport(store: RxStore): void;
+/**
+ * Applies the viewport inside every batch that moves its inputs, so a tab,
+ * zen mode or takeover change has it before anything renders. The inputs as
+ * they stand now are the first ones, so a batch that moves none writes nothing.
+ */
+export declare function observeViewport(store: RxStore): Unsubscribe;
+/** Records what the ResizeObserver measured and applies the viewport from it. */
+export declare function measureRoot(store: RxStore, observed: {
+    width: number;
+    height: number;
+}): void;
+/** How far in from the canvas's left edge the theme builder and the locale picker stand. */
+export declare const PICKER_INSET = 16;
+/**
+ * Where the theme builder and the locale picker stand left to right while the
+ * Explorer takes the left of the root: past it, at the canvas's own left edge.
+ * Right to left they keep their place at the other end.
+ */
+export declare function insetPastExplorer(store: RxStore, dir: 'ltr' | 'rtl'): Record<string, string>;
+//# sourceMappingURL=viewportLayout.d.ts.map

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

@@ -0,0 +1,12 @@
+import { FC } from '@dineug/r-html';
+export type ExplorerProps = {
+    readonly: boolean;
+};
+/**
+ * The Explorer's place beside the canvas: the panel at the width the layout
+ * reaches, or nothing. It reads the reach alone, so a drag of the edge renders
+ * the shell and the panel's root and nothing of the tree.
+ */
+declare const Explorer: FC<ExplorerProps>;
+export default Explorer;
+//# sourceMappingURL=Explorer.d.ts.map

package/dist/components/explorer/explorer-controller/ExplorerController.d.ts

@@ -0,0 +1,11 @@
+import { FC } from '@dineug/r-html';
+/** How long the edits must pause before an edit of a searched text searches again. */
+export declare const EDIT_SEARCH_DELAY = 100;
+/**
+ * What opens the Explorer's search and keeps it current, mounted beside the
+ * panel whether it shows or not: the find chord, the palette row's and the
+ * context menu's openings, and the searches an edit asks for.
+ */
+declare const ExplorerController: FC;
+export default ExplorerController;
+//# sourceMappingURL=ExplorerController.d.ts.map

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

@@ -0,0 +1,14 @@
+import { FC } from '@dineug/r-html';
+export type ExplorerPanelProps = {
+    /** The width the layout gives the panel, which a drag on its edge asks to change. */
+    width: number;
+    readonly: boolean;
+};
+/**
+ * The Explorer docked left of the canvas: a read-only tree of the document
+ * that jumps to what a row stands for on a click or Enter. Escape hands the
+ * keyboard back to the canvas and leaves the panel open.
+ */
+declare const ExplorerPanel: FC<ExplorerPanelProps>;
+export default ExplorerPanel;
+//# sourceMappingURL=ExplorerPanel.d.ts.map

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,90 @@
+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;
+} & NameMatches) | ({
+    kind: 'column';
+    tableId: string;
+    columnId: string;
+    name: 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;
+} | {
+    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({ field, id, tableId }: 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