@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/ui/dashboard/filterOutcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterOutcome.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/filterOutcome.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,sBAAsB,CAAC;AA2B9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,mBAAmB,EAC9B,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAC3B,IAAI,CAoEN"}

package/dist/ui/dashboard/findings.d.ts

@@ -0,0 +1,24 @@
+import { DashboardField, Issue, ViewConfig } from '../../model/index.js';
+import { DashboardController } from '../../react/index.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/**
+ * A finding about one of the board's filters, saying it the way the bar
+ * does — by its name, 「仓库」 — rather than by its key. A key the board
+ * has no filter for (an address naming one since removed) is all there is
+ * to say, and stays.
+ */
+export declare function filterNamer(fields: readonly DashboardField[]): (found: Issue) => Issue;
+/**
+ * How a finding the board says above its panels (`DashboardController.issues`)
+ * is said there — the one reading the workbench's status line and an
+ * embed's strips share (Q-01). A filter by its name on the bar
+ * (`filterNamer`). A panel by its name: the kernel's sentence says
+ * 「这个面板」, plain in a panel's own frame and naming nothing up here;
+ * and the fields in it by the names that frame gives them (「状态」不支持
+ * 「等于」, `outPanelNamer`), never the keys the config holds. It
+ * is the draft the finding was raised against, so the draft's panel is the
+ * one named — by the name the grid gives it, or, for a panel only the draft
+ * holds, by its own title or kind, counted where the draft has it.
+ */
+export declare function boardFindingNamer(dashboard: Pick<DashboardController, 'panels' | 'filterFields'>, draft: ViewConfig | undefined, messages: MessageFormatters): (found: Issue) => Issue;
+//# sourceMappingURL=findings.d.ts.map

package/dist/ui/dashboard/findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findings.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/findings.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,cAAc,EAEd,KAAK,EACL,UAAU,EACX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAsBpE;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,cAAc,EAAE,GAChC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CAUzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,cAAc,CAAC,EAC/D,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,QAAQ,EAAE,iBAAiB,GAC1B,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,CA2BzB"}

package/dist/ui/dashboard/gridBlocks.d.ts

@@ -0,0 +1,55 @@
+/**
+ * How far a board's rows outside the grid — its head, its filter bar —
+ * stand in from the board's edge: the grid's own padding, so they line up
+ * with the panels' edges. They stood at the edge while the panels stood
+ * 10px in, and on porcelain's grey ground the filter chip read as pinned to
+ * the frame (2026-09-27 review).
+ */
+export declare const BOARD_INSET: number;
+/**
+ * How tall a block is (D34): the row, a fixed height whatever the width,
+ * cut into the number of blocks — one gap between each — that comes nearest
+ * a square as wide as a column. One block at 1920px (70×80), two at 1200px
+ * (40×35), three at 776px (22×20). The row's own edges are always a block's
+ * edges, so a panel's top and bottom land on one; the cuts inside a row are
+ * a finer ruler than a panel can land on.
+ */
+export declare function blockHeight(rowHeight: number, column: number): number;
+/** What the grid is laid out at: the width it was handed, its columns, its row. */
+export interface GridBlocksInput {
+    width: number;
+    cols: number;
+    rowHeight: number;
+}
+/** One block of the row, in the grid's own pixels. */
+export interface GridBlock {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * The board's cells while it is built, as the one row of blocks the
+ * `dashboard-grid-blocks` layer repeats down the grid (`GridBlocksLayer`): a
+ * soft block, as near a square as the row allows (`blockHeight`), in each
+ * column of each row.
+ *
+ * `blocks` is the shape of one row — as wide as the grid, the row's blocks
+ * down each column — `pitch` how tall a repeat of it is (a row and a gap),
+ * and `top` where the first repeat starts (the grid's padding). Each
+ * column's left edge and width are the library's own sums
+ * (`calcGridItemPosition`, rounded as it rounds a panel's), and the row is
+ * the one the grid is laid out with, so a block's edge and a panel's edge
+ * are one computation and never two that agree today.
+ *
+ * `undefined` for a grid not measured yet — no blocks are better than blocks
+ * at a width the panels are not at.
+ */
+export declare function gridBlocks({ width, cols, rowHeight }: GridBlocksInput): {
+    width: number;
+    pitch: number;
+    top: number;
+    radius: number;
+    blocks: GridBlock[];
+} | undefined;
+//# sourceMappingURL=gridBlocks.d.ts.map

package/dist/ui/dashboard/gridBlocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gridBlocks.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/gridBlocks.ts"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAQ,CAAC;AA0BjC;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAQrE;AAED,mFAAmF;AACnF,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,sDAAsD;AACtD,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,eAAe,GAClE;IACE,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB,GACD,SAAS,CAcZ"}

package/dist/ui/dashboard/gridPlacement.d.ts

@@ -0,0 +1,38 @@
+import { Compactor, EventCallback } from 'react-grid-layout';
+import { PanelLayout } from '../../model/index.js';
+/** What `DashboardGrid` hands the grid so a pointer places by the kernel's rules. */
+export interface GridPlacement {
+    compactor: Compactor;
+    onDragStart: EventCallback;
+    onDragStop: EventCallback;
+    onResizeStart: EventCallback;
+    onResizeStop: EventCallback;
+}
+/**
+ * A pointer's drag and resize, placed by the same rules as a keyboard step.
+ *
+ * Left to itself the grid resolves a collision its own way: with no
+ * compaction it lets a resized panel sit on top of its neighbour, and a
+ * dragged one either overlaps or trades rows with what it lands on. The
+ * keyboard goes through the kernel (`placePanel`), which pushes the covered
+ * panels down, and two rules for one grid would show the user two answers
+ * to the same move.
+ *
+ * So the library is told panels may overlap — it resolves nothing itself —
+ * and the "compactor" it calls on every move is the kernel's placement of
+ * the panel in hand against the layout as it was when the gesture began.
+ * The preview under the pointer is therefore exactly the layout the drop
+ * applies, and a panel pushed out of the way comes back if the dragged one
+ * moves on, as it would had the drag stopped there. On the drop only the
+ * panel in hand is handed to `place`; the runtime pushes the rest by the
+ * same rule. Outside a gesture — on mount, on every new layout — it changes
+ * nothing, because the grid shows the layout as it was admitted.
+ *
+ * A resize that changed the panel's size says so (`fixedHeight`, D68): the
+ * author sized it by hand, and a board read draws it at that size. One let
+ * go at the size it started from places nothing, so it neither marks the
+ * panel nor leaves an edit to save. A drag says nothing, and the panel keeps
+ * what it had.
+ */
+export declare function useGridPlacement(place: (panelId: string, layout: PanelLayout) => void): GridPlacement;
+//# sourceMappingURL=gridPlacement.d.ts.map

package/dist/ui/dashboard/gridPlacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gridPlacement.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/gridPlacement.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,SAAS,EACT,aAAa,EAGd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,qFAAqF;AACrF,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,aAAa,CAAC;IAC3B,UAAU,EAAE,aAAa,CAAC;IAC1B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,aAAa,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,KAAK,IAAI,GACpD,aAAa,CAoDf"}

package/dist/ui/dashboard/gridWidth.d.ts

@@ -0,0 +1,33 @@
+import { DashboardWidth } from '../../model/index.js';
+/**
+ * The grid's width, known before the frame it is drawn in paints.
+ *
+ * `react-grid-layout`'s own `useContainerWidth` starts at 1280px, first
+ * measures in a passive effect, and then hears a resize from its observer
+ * only to put it off to the next animation frame — whose update React then
+ * renders a task later still. So on a first render the wide 24-column layout
+ * was handed over at 1280px, on a phone too; and on every resize, and on a
+ * board opened again from 「返回」 whose page grew a scrollbar as its panels
+ * came in, the grid was painted for a frame or two at the width the container
+ * had just lost: wider than its box, the right-hand panels hanging past it.
+ *
+ * So the width is kept here. The container is measured in a layout effect,
+ * whose update React applies before it paints, and the panels are not drawn
+ * until it has been; and the observer's answer is applied at once
+ * (`flushSync`) inside its callback, which the browser runs after layout and
+ * before paint — the grid is laid out at the new width in the same frame
+ * the container took it. On the server, where no effect runs, the panels are
+ * left out rather than drawn at a guessed width (the client's first render
+ * matches, so hydration does too); where the container measures 0 — hidden,
+ * or a DOM without layout — the starting width stands, as it always did.
+ *
+ * The same goes for the board's own width switched (D31, `boardWidth`): the
+ * container is narrower or wider at once, and is measured before that paints
+ * rather than a frame after, with the panels spilling out of it meanwhile.
+ */
+export declare function useGridWidth(boardWidth: DashboardWidth): {
+    containerRef: import('react').RefObject<HTMLDivElement | null>;
+    width: number;
+    measured: boolean;
+};
+//# sourceMappingURL=gridWidth.d.ts.map

package/dist/ui/dashboard/gridWidth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gridWidth.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/gridWidth.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,cAAc;;;;EA8BtD"}

package/dist/ui/dashboard/history.d.ts

@@ -0,0 +1,56 @@
+import { KeyboardEvent, RefObject } from 'react';
+import { DashboardController } from '../../react/index.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/** 撤销 and 重做 as the edit bar draws them. */
+export interface BoardHistory {
+    /** The button's name: 「撤销」, or 「撤销移除「北区订单」」 when there is a step. */
+    undoLabel: string;
+    redoLabel: string;
+    canUndo: boolean;
+    canRedo: boolean;
+    undo(): void;
+    redo(): void;
+    /**
+     * ⌘Z／Ctrl+Z, and ⇧⌘Z／Ctrl+Shift+Z／Ctrl+Y, on the board — never inside
+     * a field, whose own undo the keys are, nor inside a dialog or a popup
+     * the board opened (those are not in `board`, whatever React's tree says).
+     */
+    onKeyDown(event: KeyboardEvent<HTMLElement>): void;
+    /**
+     * Puts the keyboard on 「撤销」 once the board has drawn what a removal
+     * left — where a panel that went is brought back from.
+     */
+    land(): void;
+}
+export interface BoardHistoryInput {
+    dashboard: DashboardController;
+    /** Every panel's name by id, as the board names them now. */
+    names: ReadonlyMap<string, string>;
+    messages: MessageFormatters;
+    /** Whether the board is being built: undo is building's alone. */
+    editing: boolean;
+    /** Says a line once, in the board's live region. */
+    say(line: string): void;
+    /** The board: where the keys are listened for. */
+    board: RefObject<HTMLElement | null>;
+    undoRef: RefObject<HTMLButtonElement | null>;
+    redoRef: RefObject<HTMLButtonElement | null>;
+    /** The edit bar's name: where the keyboard goes when neither button can take it. */
+    landing: RefObject<HTMLElement | null>;
+}
+/**
+ * The board's undo and redo (`DashboardEditing.undo`, `redo`) as a screen
+ * offers them: named after the step they would take (a panel that went is
+ * still named, since the names seen while the board was built are kept),
+ * said aloud when taken, and the keyboard never left on nothing.
+ *
+ * The keyboard: a press that disables its own button moves to the other
+ * one, as a move button's does at the end of a list (`listFocus.ts`); a
+ * step taken by key that took the focused control with it — a panel added
+ * then taken back — lands on 「撤销」, or 「重做」, or the edit bar.
+ */
+export declare function useBoardHistory({ dashboard, names, messages, editing, say, board, undoRef, redoRef, landing, }: BoardHistoryInput): BoardHistory;
+/** The keys each button answers, said on it (`aria-keyshortcuts`). */
+export declare const UNDO_KEYS = "Meta+Z Control+Z";
+export declare const REDO_KEYS = "Meta+Shift+Z Control+Shift+Z Control+Y";
+//# sourceMappingURL=history.d.ts.map

package/dist/ui/dashboard/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/history.ts"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAwCpE,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,IAAI,IAAI,CAAC;IACb,IAAI,IAAI,IAAI,CAAC;IACb;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;IACnD;;;OAGG;IACH,IAAI,IAAI,IAAI,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,6DAA6D;IAC7D,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,kEAAkE;IAClE,OAAO,EAAE,OAAO,CAAC;IACjB,oDAAoD;IACpD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,kDAAkD;IAClD,KAAK,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACrC,OAAO,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC7C,OAAO,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC7C,oFAAoF;IACpF,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,EAC9B,SAAS,EACT,KAAK,EACL,QAAQ,EACR,OAAO,EACP,GAAG,EACH,KAAK,EACL,OAAO,EACP,OAAO,EACP,OAAO,GACR,EAAE,iBAAiB,GAAG,YAAY,CAqFlC;AAoDD,sEAAsE;AACtE,eAAO,MAAM,SAAS,qBAAqB,CAAC;AAC5C,eAAO,MAAM,SAAS,2CAA2C,CAAC"}

package/dist/ui/dashboard/landing.d.ts

@@ -0,0 +1,13 @@
+/** The board a control is on: the grid's column, header and all. */
+export declare function boardOf(from: Element | null | undefined): Element | null;
+/** One filter's chip on the bar, by the filter's name. */
+export declare function chipOf(board: Element | null, name: string): HTMLElement | undefined;
+/** The filters' chips on the bar, in its order. */
+export declare function chipsOf(board: Element | null): HTMLElement[];
+/** A chip's value control: what a reader edits the filter with. */
+export declare function valueOf(chip: Element | null | undefined): Element | null;
+/** 「撤销」 on the edit bar: where a step that took its own control away lands. */
+export declare function undoOf(board: Element | null): Element | null;
+/** 「添加筛选」 on the edit bar. */
+export declare function addFilterOf(board: Element | null): Element | null;
+//# sourceMappingURL=landing.d.ts.map

package/dist/ui/dashboard/landing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"landing.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/landing.ts"],"names":[],"mappings":"AAaA,oEAAoE;AACpE,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,IAAI,CAExE;AAED,0DAA0D;AAC1D,wBAAgB,MAAM,CACpB,KAAK,EAAE,OAAO,GAAG,IAAI,EACrB,IAAI,EAAE,MAAM,GACX,WAAW,GAAG,SAAS,CAEzB;AAED,mDAAmD;AACnD,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,WAAW,EAAE,CAM5D;AAED,mEAAmE;AACnE,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,IAAI,CAExE;AAED,+EAA+E;AAC/E,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAE5D;AAED,8BAA8B;AAC9B,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAEjE"}

package/dist/ui/dashboard/panelFit.d.ts

@@ -0,0 +1,43 @@
+import { PlacedPanel } from '../../dashboard/index.js';
+/**
+ * How many rows a panel grows to at most while its board is read: eight
+ * 80px rows are 710px, a panel a laptop's screen still shows whole under
+ * the board's header, so a table longer than that scrolls inside a panel
+ * the reader sees all of — its header, its cue and its paging — rather
+ * than one that runs off the page. A panel its author made taller keeps
+ * its height.
+ */
+export declare const GROWS_TO_ROWS = 8;
+/**
+ * The height, in pixels, each panel on screen needs to draw its body whole,
+ * as each panel reports it (`DashboardPanel.onWhole`), and a reporter per
+ * panel that keeps its identity, so reporting is an effect on the height
+ * alone.
+ */
+export declare function usePanelWholes(): {
+    wholes: ReadonlyMap<string, number>;
+    reporter(id: string): (height: number) => void;
+};
+/**
+ * The rows each panel grows to (P1-3, D52), by id, for the panels that
+ * grow: one whose body holds more than its saved height shows — a table's
+ * rows, a note's lines — grows by whole rows until it holds it all or
+ * reaches `GROWS_TO_ROWS`. A panel never shrinks: the author's height is
+ * the least it gets, so a short table beside a chart keeps the row they
+ * share even. A panel its author sized by hand (`fixedHeight`, D68) is
+ * drawn at that size and never grows: what they dragged is what a reader
+ * sees, and the cue says what is past its bottom.
+ *
+ * The same on a board read and a board built (D68): 「编辑」 starts from the
+ * heights the reader saw, so nothing jumps, and a hand places against the
+ * board as drawn (`DashboardRuntime.place`'s `grown`).
+ */
+export declare function grownRows(boxes: readonly PlacedPanel[], wholes: ReadonlyMap<string, number>, rowHeight: number): ReadonlyMap<string, number>;
+/**
+ * The layout a board is drawn in: each panel grown to its `grownRows`, and
+ * whatever stood under it moved down with it (`grownLayout`).
+ */
+export declare function fittedLayout(boxes: readonly PlacedPanel[], heights: ReadonlyMap<string, number>): PlacedPanel[];
+/** The fewest grid rows a panel `height` pixels tall fits in. */
+export declare function rowsFor(height: number, rowHeight: number): number;
+//# sourceMappingURL=panelFit.d.ts.map

package/dist/ui/dashboard/panelFit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panelFit.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/panelFit.ts"],"names":[],"mappings":"AAeA,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AASzE;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI;IAChC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAChD,CAwBA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACnC,SAAS,EAAE,MAAM,GAChB,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAU7B;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,WAAW,EAAE,CAEf;AAED,iEAAiE;AACjE,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAGjE"}

package/dist/ui/dashboard/press.d.ts

@@ -0,0 +1,50 @@
+import { DashboardField, DataViewConfig, PanelClick, RecordData } from '../../model/index.js';
+import { DashboardController, DashboardPanelView } from '../../react/index.js';
+import { CrossFilterOutcome, HandOver, ViewNavigation, PressDestination, ViewRuntime } from '../../runtime/index.js';
+import { DisplayContext } from '../kit/display.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/**
+ * What a press on one group of a panel can do, as the grid hands it to the
+ * panel (D22 H, I): its click, the host's route, and the board's commands
+ * on this panel's groups.
+ */
+export interface PanelPress {
+    click: PanelClick | null;
+    /** The host's route; the follow-up menu and a destination need it. */
+    navigate?(to: ViewNavigation): void;
+    crossFilter(row: RecordData): CrossFilterOutcome;
+    pressed(row: RecordData): boolean;
+    /** The date filters a span of the panel's time axis can set (D33 Q52). */
+    spanFilters(): readonly DashboardField[];
+    /** A span of the panel's time axis set into one of them. */
+    pressSpan(name: string, row: RecordData, through: RecordData): CrossFilterOutcome;
+    destination(row: RecordData): Promise<PressDestination | null>;
+    /** What the panel's view takes off the board (D26 Q30), read at the press. */
+    handOver(): HandOver | null;
+    /** Says one line to whoever cannot see what a press changed. */
+    say(text: string): void;
+}
+/** One panel's press, over the board's commands. */
+export declare function panelPress(panel: DashboardPanelView, dashboard: DashboardController, navigate: ((to: ViewNavigation) => void) | undefined, say: (text: string) => void): PanelPress;
+/**
+ * What a press does on this panel, or `null` for nothing: a click that sets
+ * a filter works on any page; the follow-up menu and a destination go away
+ * from the board, so they are there only with a route to go by (D22 H:
+ * 「宿主没给路由钩子时，不出追问菜单」).
+ */
+export type PressMode = 'menu' | 'filter' | 'go';
+export declare function pressMode(press: PanelPress | undefined): PressMode | null;
+/**
+ * The board's filters as they reach the panel, in the applied bar's words,
+ * one after another — what the follow-up menu says the group is read under
+ * (D22 H, 「仓库 是 华南 · 本月」); `undefined` when none reaches it.
+ */
+export declare function boardContext(runtime: ViewRuntime<DataViewConfig>, messages: MessageFormatters, display: DisplayContext): string | undefined;
+/**
+ * What a press that set a filter says it did. A set says which group it
+ * set the filter to (`group`, as the follow-up menu heads it): a press on
+ * another group is another sentence, so it is read out again (U-05) — the
+ * same words twice are one announcement.
+ */
+export declare function crossFilterSaid(outcome: CrossFilterOutcome, messages: MessageFormatters, group?: string): string | null;
+//# sourceMappingURL=press.d.ts.map

package/dist/ui/dashboard/press.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"press.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/press.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,UAAU,EACV,UAAU,EACX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,kBAAkB,EAClB,QAAQ,EACR,cAAc,EACd,gBAAgB,EAChB,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAGpE;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAAC;IACpC,WAAW,CAAC,GAAG,EAAE,UAAU,GAAG,kBAAkB,CAAC;IACjD,OAAO,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC;IAClC,0EAA0E;IAC1E,WAAW,IAAI,SAAS,cAAc,EAAE,CAAC;IACzC,4DAA4D;IAC5D,SAAS,CACP,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,UAAU,GAClB,kBAAkB,CAAC;IACtB,WAAW,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;IAC/D,8EAA8E;IAC9E,QAAQ,IAAI,QAAQ,GAAG,IAAI,CAAC;IAC5B,gEAAgE;IAChE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,oDAAoD;AACpD,wBAAgB,UAAU,CACxB,KAAK,EAAE,kBAAkB,EACzB,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,cAAc,KAAK,IAAI,CAAC,GAAG,SAAS,EACpD,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAC1B,UAAU,CAaZ;AAED;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;AAEjD,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI,CAKzE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,CAAC,cAAc,CAAC,EACpC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,cAAc,GACtB,MAAM,GAAG,SAAS,CAUpB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,SAAK,GACT,MAAM,GAAG,IAAI,CAaf"}

package/dist/ui/dashboard/reveal.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from 'react';
+/**
+ * A panel just added, brought where it can be seen (R2-38): placed from
+ * the first row on screen, a full board puts it below everything — 2,500
+ * pixels down on a board of eight panels — and 「已添加」 in the live region
+ * was all a sighted builder got, who then added it a second time.
+ *
+ * Once the panel is drawn it is scrolled into view (`block: 'nearest'`, so a
+ * panel already on screen does not move the page), and the keyboard — when
+ * it is still on 「＋ 添加」 the dialog handed it back to, or fell — goes to
+ * the panel's 「⋯」. `returnTo` is what a dialog closing after the panel
+ * landed hands the keyboard to instead of 「＋ 添加」.
+ */
+export declare function usePanelReveal(board: RefObject<HTMLElement | null>, add: RefObject<HTMLElement | null>): {
+    reveal(panelId: string): void;
+    /** Forgets the last one: a new add is under way. */
+    reset(): void;
+    /** The last added panel's 「⋯」, while it is on the board. */
+    returnTo(): HTMLElement | null;
+};
+//# sourceMappingURL=reveal.d.ts.map

package/dist/ui/dashboard/reveal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/reveal.ts"],"names":[],"mappings":"AAaA,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAiB1D;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACpC,GAAG,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,GACjC;IACD,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,oDAAoD;IACpD,KAAK,IAAI,IAAI,CAAC;IACd,4DAA4D;IAC5D,QAAQ,IAAI,WAAW,GAAG,IAAI,CAAC;CAChC,CA+BA"}

package/dist/ui/dashboard/scrollMore.d.ts

@@ -0,0 +1,92 @@
+import { CSSProperties } from 'react';
+/** Which of a scroll port's sides have more of its content past them. */
+export type ScrollMore = 'start' | 'end' | 'both';
+/** How far in from an edge the content fades out. */
+export declare const SCROLL_FADE = 32;
+/**
+ * What is past a panel body's edges, and how tall the panel would have to
+ * be to show its body whole.
+ */
+export interface ScrollState {
+    /** The sides, across, with columns past them. */
+    more?: ScrollMore;
+    /** Whether there is more of the body under its bottom edge. */
+    below?: boolean;
+    /** The table's rows not wholly in view under the bottom edge. */
+    rows?: number;
+    /** The table's columns not wholly in view past the end edge. */
+    columns?: number;
+    /**
+     * How far up from the port's bottom edge a cue may stand clear of what
+     * the port holds on to there: its horizontal scrollbar and a table's
+     * sticky totals band.
+     */
+    inset: number;
+    /**
+     * The height, in pixels, the port's parent — the panel's card — would
+     * need to draw the body whole; `0` where the body's size is not its
+     * content's (a chart, an empty state fill whatever room they are given).
+     */
+    whole: number;
+}
+/** The mask that fades the sides across; nothing when no side has more. */
+export interface ScrollMoreResult extends ScrollState {
+    style?: CSSProperties;
+}
+/**
+ * What a panel's body has past its edges, the fade that says so across,
+ * and what the panel needs to show it whole (P1-3).
+ *
+ * A panel's table wider than the panel scrolls sideways in the panel's
+ * body, and on a system that hides its scrollbars until they are used —
+ * macOS by default — nothing on screen said so: the console's cluster
+ * panel read as six columns, its seventh 「最早下次重试」 cut at the edge
+ * with no sign there was more (compensation console walkthrough, W13). The
+ * content now fades out towards a side that has more past it, the way a
+ * list that scrolls on a phone does, and stops fading once scrolled there;
+ * the body is a Tab stop, so the arrow keys scroll it too. Down, a fade
+ * would wash out the table's sticky header and totals band, so what is
+ * under the bottom edge is counted instead — the rows (and the columns
+ * past the end) not wholly in view, which the panel says in a cue.
+ *
+ * The fade is a mask on the port itself, so it covers whatever the body
+ * draws — the sticky header and totals bands included — without a layer
+ * over them that could take a click. It stops short of the port's own
+ * scrollbar, which stays whole. Measured on scroll, when the port or a
+ * table in it resizes, and when what the port holds changes (a result
+ * arrives) — a chart redrawing itself is not that — at most once a frame.
+ *
+ * `fits` says the body's content keeps its own height even without a
+ * table — a note, a list of links — so its whole height is worth asking
+ * for; a table's always is.
+ */
+export declare function useScrollMore(
+/** The port, as a callback ref hands it over; `null` while there is none. */
+node: HTMLElement | null, fits?: boolean): ScrollMoreResult;
+/** One reading of the port: what is past its edges, and its whole height. */
+export declare function measurePort(node: HTMLElement, fits?: boolean): ScrollState & {
+    bar: number;
+};
+/**
+ * The rows of a table not wholly above `floor`. A table drawn virtually
+ * (`aria-rowcount`) holds only the rows around the view, so the rows it
+ * does not draw are counted from where the last row in view stands.
+ */
+export declare function rowsUnder(table: HTMLTableElement, floor: number): number;
+/** The header's columns not wholly before `edge` — the filler aside. */
+export declare function columnsPast(table: HTMLTableElement, edge: number): number;
+/**
+ * The height the port's parent needs to draw the port's content whole: the
+ * parent as it stands, less the port's inner height, plus the height the
+ * content takes — measured off the blocks it stacks rather than
+ * `scrollHeight`, which never reads less than the port, so a panel that
+ * grew for a long page would never learn the next page is short.
+ */
+export declare function wholeHeight(node: HTMLElement): number;
+/**
+ * The mask that fades the content out towards each side with more past it,
+ * over `SCROLL_FADE` pixels, and leaves `bar` pixels at the end — the
+ * port's vertical scrollbar — drawn whole.
+ */
+export declare function fadeMask(more: ScrollMore, bar: number): CSSProperties;
+//# sourceMappingURL=scrollMore.d.ts.map

package/dist/ui/dashboard/scrollMore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollMore.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/scrollMore.ts"],"names":[],"mappings":"AAaA,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtE,yEAAyE;AACzE,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAElD,qDAAqD;AACrD,eAAO,MAAM,WAAW,KAAK,CAAC;AAQ9B;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,2EAA2E;AAC3E,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,aAAa;AAC3B,6EAA6E;AAC7E,IAAI,EAAE,WAAW,GAAG,IAAI,EACxB,IAAI,UAAQ,GACX,gBAAgB,CA0DlB;AAmBD,6EAA6E;AAC7E,wBAAgB,WAAW,CACzB,IAAI,EAAE,WAAW,EACjB,IAAI,UAAQ,GACX,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAwC/B;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiBxE;AAWD,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQzE;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAcrD;AAQD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAarE"}

package/dist/ui/dashboard/touchGate.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A grid item's `touchstart` listeners, held back while the board is only
+ * read.
+ *
+ * `react-grid-layout` wraps every item in `react-draggable`'s `DraggableCore`
+ * whether or not a panel may be moved, and that component adds a
+ * `touchstart` listener to the item as it mounts — non-passive and in the
+ * capture phase, so it may cancel a drag's scroll — and takes it away only
+ * as it unmounts; `disabled` stops the drag and leaves the listener. On a
+ * board nobody builds, every scroll a finger starts on a panel then waits
+ * for the main thread to say it will not be cancelled, which on a busy page
+ * is a scroll that sticks (a read board's charts draw on that thread).
+ *
+ * Turning the listener off by unmounting it would remount the panel with it:
+ * the item is the panel's parent, and entering or leaving the building would
+ * run every panel's query again. So the item keeps what the library adds
+ * and hands it to the element only while the board is built: `open` adds
+ * every held listener, `close` takes them away again, and a listener added
+ * or removed meanwhile is only noted. Every other event goes straight
+ * through. The library is not told — it added its listener once, and it
+ * gets its drag whenever the board is built.
+ */
+export interface TouchGate {
+    /** Hands the held listeners to the element (`true`) or takes them back. */
+    set(open: boolean): void;
+    /** Puts the element's own methods back. */
+    release(): void;
+}
+export declare function gateTouchStart(element: HTMLElement): TouchGate;
+//# sourceMappingURL=touchGate.d.ts.map

package/dist/ui/dashboard/touchGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchGate.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/touchGate.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,SAAS;IACxB,2EAA2E;IAC3E,GAAG,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,2CAA2C;IAC3C,OAAO,IAAI,IAAI,CAAC;CACjB;AAID,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,CA4D9D"}

package/dist/ui/embed/EmbedFrame.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { ViewKind } from '../../model/index.js';
+import { AnyViewRuntime, ViewEngine } from '../../runtime/index.js';
+import { OpenViewState } from '../../react/index.js';
+import { EmbedBaseProps } from './options.js';
+/**
+ * What both embeds are drawn inside: the surface — its theme, wording,
+ * language and zone, and how tall it is (`data-embed-size`) — the opening
+ * and what can go wrong with it, and one render boundary around the rest.
+ *
+ * Opening can go wrong three ways, each said here and nowhere else: the view
+ * cannot be opened; it opened but is of a kind this entry does not draw (a
+ * dashboard named to `EmbeddedView`, a record view to `EmbeddedDashboard` —
+ * the two are split by resource, as the workbenches are); or the page's own
+ * narrowing was refused, which is never shown in silence (D17-5).
+ *
+ * An entry that draws one kind says what it opens by that kind's word, here
+ * and below (`SurfaceKind`): an embedded board that cannot be opened is a
+ * dashboard that cannot be opened (Q34). One that draws several says view.
+ */
+export declare function EmbedFrame({ engine, opened, kinds, props, children, }: {
+    engine: ViewEngine;
+    opened: OpenViewState;
+    /** The kinds this entry draws. */
+    kinds: readonly ViewKind[];
+    props: EmbedBaseProps;
+    children(runtime: AnyViewRuntime): ReactNode;
+}): import('react').JSX.Element;
+//# sourceMappingURL=EmbedFrame.d.ts.map

package/dist/ui/embed/EmbedFrame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbedFrame.d.ts","sourceRoot":"","sources":["../../../src/ui/embed/EmbedFrame.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,sBAAsB,CAAC;AAS9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,EACzB,MAAM,EACN,MAAM,EACN,KAAK,EACL,KAAK,EACL,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,aAAa,CAAC;IACtB,kCAAkC;IAClC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC3B,KAAK,EAAE,cAAc,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,SAAS,CAAC;CAC9C,+BAmGA"}

package/dist/ui/embed/EmbedHead.d.ts

@@ -0,0 +1,81 @@
+import { ReactNode } from 'react';
+import { RefreshController } from '../../react/index.js';
+import { ViewNavigation } from '../../runtime/index.js';
+import { PanelHeadingLevel } from '../dashboard/DashboardPanel.js';
+/**
+ * An embed's first row, when it has one: its title as a heading at the
+ * level the host's outline calls for — and under it, where handed one, the
+ * words that say what the numbers are read as (D70) — and on the right
+ * what the host switched on — 在工作台中打开, the export, 「铺满屏幕」.
+ * Nothing at all when there is neither: an embed is its result, and a row
+ * of chrome nobody asked for is what it exists not to add (D10).
+ */
+export declare function EmbedHead({ title, caption, headingLevel, inset, children, }: {
+    /** The title to draw; left out, none. */
+    title?: string | undefined;
+    /** Under the title, where there is one (`EmbeddedDashboard.caption`). */
+    caption?: ReactNode;
+    headingLevel: PanelHeadingLevel;
+    /**
+     * How far it stands in from the edge, in pixels: a board's, in line with
+     * its panels (`BOARD_INSET`); none for a view, whose result runs to the
+     * edge.
+     */
+    inset?: number;
+    /** The controls on the right. */
+    children?: ReactNode;
+}): import('react').JSX.Element | null;
+/**
+ * 在工作台中打开, for an embedded view: the saved view itself under the
+ * page's narrowing, in its own field names, handed to the host's route —
+ * the same `{ kind: 'view' }` a dashboard panel's menu hands over. What the
+ * reader did here (a sort, a page, a search) is not carried: the workbench
+ * opens the view as its author saved it.
+ */
+export declare function OpenInWorkbench({ to, onNavigate, }: {
+    to: ViewNavigation;
+    onNavigate(to: ViewNavigation): void;
+}): import('react').JSX.Element;
+/**
+ * 「铺满屏幕」 on an embed (`EmbedBaseProps.expandable`, D36): the surface
+ * the button stands on fills the screen in place — the same
+ * `useViewExpansion` a workbench's title bar holds, pointed at the embed's
+ * own `.fve-root` through the button itself — and Escape or the button
+ * again puts it back. The control is inside the surface, so it stays on
+ * screen while the surface fills it and the surface's own exit stays
+ * hidden.
+ */
+export declare function EmbedExpand(): ReactNode;
+/**
+ * `EmbedExpand` held by the caller, for an embed that decides where the
+ * button stands (`EmbeddedDashboard`: its first row, else the end of the
+ * filter bar or the tabs, D10) and what it draws while the screen is its
+ * (D70: a title and the caption). The expansion lives with the caller, so
+ * the button moving between rows — the filter bar giving way as the board
+ * narrows — never ends it. No button while `enabled` is off.
+ */
+export declare function useEmbedExpand(enabled: boolean): {
+    toggle: ReactNode;
+    expanded: boolean;
+};
+/**
+ * How fresh an embedded board's numbers are, where the host asked
+ * (`withRefresh`): 「更新于 10:32」 — when the panels on screen were read,
+ * the earliest of them — and, in the interactive tier, the workbench's
+ * refresh button beside it, the same control and the same spinner, without
+ * the interval menu: how often the board renews itself is its author's and
+ * the host's `autoRefresh`. Refreshing asks the source again and writes
+ * nothing (D36). The static tier has no controls, so it reads the time
+ * alone.
+ */
+export declare function EmbedFreshness({ readAt, now, refresh, busy, }: {
+    /** When the numbers on screen were read (`DashboardController.readAt`). */
+    readAt: number | null;
+    /** The runtime's clock, which `readAt` is on. */
+    now(): Date;
+    /** The press, in a tier with controls; left out, the time alone. */
+    refresh?: RefreshController;
+    /** Whether a refresh would only replace requests already out. */
+    busy: boolean;
+}): import('react').JSX.Element;
+//# sourceMappingURL=EmbedHead.d.ts.map