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

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

@@ -0,0 +1,30 @@
+import { DashboardController, DashboardPanelView } from '../../react/index.js';
+import { ViewEngine } from '../../runtime/index.js';
+import { FinalFocus } from '../kit/focus.js';
+export interface ClickSettingsProps {
+    engine: ViewEngine;
+    dashboard: DashboardController;
+    /** The panel whose press is set, and its name; kept while it closes. */
+    panel: DashboardPanelView | null;
+    name: string;
+    open: boolean;
+    onClose(): void;
+    finalFocus: FinalFocus;
+    /**
+     * Whether the page has a route to the workbench: without one the
+     * follow-up menu opens nothing, and the default says so.
+     */
+    routed: boolean;
+}
+/**
+ * 「点击时…」 (D22 I): what pressing one group of an analysis panel does —
+ * the follow-up menu (the default, D22 H), setting a board filter the panel
+ * is wired to through a field it groups by (cross-filtering), or going to
+ * another saved view, another board (its filters mapped one by one, D23
+ * Q17: `BoardDestination`) or a page of the host's, the group carried
+ * along. One choice among three, so a `RadioGroup`; what each choice needs
+ * sits under it. 「完成」 writes it into the draft (`setPanelClick`), as every
+ * edit of a board is; the board's own 「保存」 saves it.
+ */
+export declare function ClickSettings({ engine, dashboard, panel, name, open, onClose, finalFocus, routed, }: ClickSettingsProps): import('react').JSX.Element;
+//# sourceMappingURL=ClickSettings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ClickSettings.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/ClickSettings.tsx"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AA0BzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAQlD,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,wEAAwE;IACxE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,IAAI,IAAI,CAAC;IAChB,UAAU,EAAE,UAAU,CAAC;IACvB;;;OAGG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,SAAS,EACT,KAAK,EACL,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,UAAU,EACV,MAAM,GACP,EAAE,kBAAkB,+BAsBpB"}

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

@@ -0,0 +1,40 @@
+import { FinalFocus } from '../kit/focus.js';
+import { NewContentPanel } from '../../dashboard/index.js';
+import { DashboardContentPanel } from '../../model/index.js';
+/** The content panels a form edits; a heading is named in place instead. */
+export type EditedKind = 'markdown' | 'image' | 'links';
+/** What the form is for: a new panel of a kind, or one already on the board. */
+export type ContentTarget = {
+    mode: 'add';
+    kind: EditedKind;
+} | {
+    mode: 'edit';
+    panelId: string;
+    panel: Extract<DashboardContentPanel, {
+        kind: EditedKind;
+    }>;
+};
+export interface ContentEditorProps {
+    /** What the last opening was for; kept while it closes. */
+    target: ContentTarget | null;
+    open: boolean;
+    onClose(): void;
+    /** Where the keyboard goes once it closes — the menu that asked is gone. */
+    finalFocus: FinalFocus;
+    /**
+     * The panel as the form left it: every member, a blank optional one
+     * `undefined` — so an edit takes a cleared address off rather than
+     * leaving an empty one the kernel would refuse.
+     */
+    onSubmit(content: NewContentPanel & {
+        kind: EditedKind;
+    }): void;
+}
+/**
+ * The small form a note, a picture or a list of links is written in (D22 A):
+ * minimal, and complete — what the kernel would refuse (an address it does
+ * not load, a link without words) is said at the field before the panel is
+ * written, never after. A title of its own is optional, as on every panel.
+ */
+export declare function ContentEditor({ target, open, onClose, finalFocus, onSubmit, }: ContentEditorProps): import('react').JSX.Element;
+//# sourceMappingURL=ContentEditor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContentEditor.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/ContentEditor.tsx"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AA0B9B,4EAA4E;AAC5E,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;AAExD,gFAAgF;AAChF,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACjC;IACE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC,qBAAqB,EAAE;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,CAAC,CAAC;CAC7D,CAAC;AAEN,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,IAAI,IAAI,CAAC;IAChB,4EAA4E;IAC5E,UAAU,EAAE,UAAU,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG;QAAE,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,IAAI,CAAC;CACjE;AAQD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,IAAI,EACJ,OAAO,EACP,UAAU,EACV,QAAQ,GACT,EAAE,kBAAkB,+BAqCpB"}

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

@@ -0,0 +1,101 @@
+import { ArrangeStep } from '../../dashboard/index.js';
+import { HandleMove } from '../kit/DragHandle.js';
+import type * as React from 'react';
+export interface PanelHandleProps {
+    /** What the panel is called, so the handle says which one it is. */
+    title: string;
+    /** One step; answers whether the panel moved at all. */
+    onStep(step: ArrangeStep): boolean;
+    /** Escape: take back the steps this arranging took, however many. */
+    onCancel(steps: number): void;
+}
+/**
+ * The panel's one handle: a pointer drags it, and a keyboard arranges with
+ * it (V-02).
+ *
+ * `data-slot="panel-grip"` is what the grid's `dragConfig.handle` selects,
+ * so the drag is the library's. Enter or Space — a click with no pointer
+ * behind it, `detail === 0`, which is also what a screen reader's "press"
+ * is — starts arranging: the handle is pressed (`aria-pressed`), the
+ * board's voice says which keys do what, and each step says where the
+ * panel landed (`label.panel.placed`). Enter or Space again, or leaving
+ * the handle, keeps where it is; Escape takes every step back, one board
+ * step each (`edit.undo`), so it lands where it started. A pointer's click
+ * without a drag does nothing: it is the start of a drag that did not
+ * happen, not a request to arrange.
+ *
+ * The arrows do nothing until arranging starts, so a reader walking the
+ * header with the arrows never moves a panel by accident.
+ */
+export declare function PanelHandle({ title, onStep, onCancel }: PanelHandleProps): React.JSX.Element;
+/** The board's voice, as the grid item a panel sits in hands it down. */
+export declare function usePanelVoice(): ((message: string) => void) | undefined;
+export interface PanelGridItemProps extends React.ComponentProps<'div'> {
+    panelId: string;
+    /** What the panel is called on screen, which its corner is named after. */
+    name: string;
+    /** The board's voice, which the panel's handle says its steps in. */
+    say?(message: string): void;
+    /**
+     * Whether the panel may be moved, and so whether the drag's `touchstart`
+     * listener is on the item at all (`gateTouchStart`): not on a board that
+     * is only read.
+     */
+    touch: boolean;
+}
+/**
+ * One grid item, and the panel it holds said to what the grid appends to it.
+ *
+ * The library builds one resize-handle factory for the whole grid and hands
+ * it only the axis — but what that factory returns is appended to *this*
+ * element's children (`react-resizable` clones the item with its handles
+ * after whatever it already held). So the corner renders inside this
+ * component, and a context provided here reaches it: that is how one corner
+ * knows it is 「北区订单」's and not the next panel's. Whatever the grid puts
+ * on the item — its class, its position, its ref, the mouse handlers —
+ * passes through to the `div` untouched; the drag's `touchstart` listener
+ * waits until the board is built (`touch`).
+ */
+export declare function PanelGridItem({ panelId, name, say, touch, children, ref, ...item }: PanelGridItemProps): React.JSX.Element;
+export interface PanelResizeHandleProps extends Pick<React.DOMAttributes<HTMLElement>, 'onMouseDown' | 'onMouseUp' | 'onTouchEnd'> {
+    /** Which corner or edge the library asked for; `se` unless told otherwise. */
+    axis: string;
+    ref: React.Ref<HTMLElement>;
+    /** Told which panel and which step; the grid holds the geometry. */
+    onStep(panelId: string, step: ArrangeStep): void;
+}
+/**
+ * The corner the pointer drags to resize, named and focusable.
+ *
+ * Named after its panel (「调整『北区订单』的大小」): a board of six panels
+ * used to offer six corners under one name, and a reader walking the page
+ * could not tell which one they were on. The panel comes from
+ * `PanelGridItem`, which the library appends this to. Outside one there is
+ * no panel to name or to resize, so the corner says so generically and
+ * answers no key rather than guessing at the first panel.
+ */
+export declare function PanelResizeHandle({ axis, ref, onStep, onMouseDown, onMouseUp, onTouchEnd, }: PanelResizeHandleProps): React.JSX.Element;
+export interface PanelOrderProps {
+    /** Which panel it carries: the id the library holds it by. */
+    panelId: string;
+    /** What the panel is called, so the handle says which one it moves. */
+    title: string;
+    /** Where the panel stands in the column, from 0, and how many there are. */
+    index: number;
+    total: number;
+    /** Moves the panel, from the arrow keys on the handle or from its menu. */
+    onMove(move: HandleMove): void;
+}
+/**
+ * The handle a panel is carried along the one-column reading by (D22 J),
+ * where the grip and the corner are not: the handle every ordered list here
+ * is (`DragHandle`, 「可排序的列表一律拖拽排序」) — dragged by a pointer onto
+ * another panel's place, moved a place by ↑／↓, picked up by Space, or
+ * clicked for the menu of the four places it can go. The runtime writes the
+ * place back onto the grid as the layout that reads that way
+ * (`reorderPanel`). It is what the grid's `DragDropProvider` sorts, the card
+ * being what the library carries; the handle is on the header, where the
+ * wide grid's grip is.
+ */
+export declare function PanelOrder({ panelId, title, index, total, onMove, }: PanelOrderProps): React.JSX.Element;
+//# sourceMappingURL=DashboardArrange.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardArrange.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/DashboardArrange.tsx"],"names":[],"mappings":"AAsBA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAIpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAgDnE,MAAM,WAAW,gBAAgB;IAC/B,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,MAAM,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC;IACnC,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,gBAAgB,qBAoFxE;AAeD,yEAAyE;AACzE,wBAAgB,aAAa,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAEvE;AAED,MAAM,WAAW,kBAAmB,SAAQ,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;;OAIG;IACH,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,IAAI,EACJ,GAAG,EACH,KAAK,EACL,QAAQ,EACR,GAAG,EACH,GAAG,IAAI,EACR,EAAE,kBAAkB,qBA+BpB;AAOD,MAAM,WAAW,sBAAuB,SAAQ,IAAI,CAClD,KAAK,CAAC,aAAa,CAAC,WAAW,CAAC,EAChC,aAAa,GAAG,WAAW,GAAG,YAAY,CAC3C;IACC,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC5B,oEAAoE;IACpE,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;CAClD;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,GAAG,EACH,MAAM,EACN,WAAW,EACX,SAAS,EACT,UAAU,GACX,EAAE,sBAAsB,qBAsCxB;AAED,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;CAChC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,GACP,EAAE,eAAe,qBAqCjB"}

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

@@ -0,0 +1,96 @@
+import { ReactNode } from 'react';
+import { DashboardController } from '../../react/index.js';
+import { ViewNavigation } from '../../runtime/index.js';
+import { PanelHeadingLevel } from './DashboardPanel.js';
+import { RenderFailureHandler } from '../kit/RenderBoundary.js';
+import { BoardFilterModes } from './filterModes.js';
+export interface DashboardGridProps {
+    dashboard: DashboardController;
+    /**
+     * Whether the board is being built (D22 A): panels may be dragged,
+     * resized and placed by keyboard, and each panel's menu offers 「编辑面板」.
+     * Read-only by default — nothing on a board being read moves it.
+     */
+    editable?: boolean;
+    /** Pixel height of one grid row. */
+    rowHeight?: number;
+    /** Told when one panel's body fails to draw; the others keep drawing. */
+    onRenderFailure?: RenderFailureHandler;
+    /**
+     * The heading level of each panel's title: one under whatever names the
+     * board. `3` under a workbench's own `h2`; an embed passes what its host's
+     * page calls for, since only the host knows its outline.
+     */
+    headingLevel?: PanelHeadingLevel;
+    /**
+     * Above the panels, inside the grid's own column: the edit bar while the
+     * board is built. Told whether the board is in its one-column reading,
+     * where building is renaming, removing and reordering alone (D22 J).
+     */
+    header?(board: {
+        narrow: boolean;
+    }): ReactNode;
+    /**
+     * Under the empty board's words: the first things to add (D22 A). Left
+     * out, an empty board says it has no panels and offers nothing — a reader
+     * who cannot build it has nothing to press.
+     */
+    emptyActions?: ReactNode;
+    /**
+     * The host's route (`ViewNavigation`): 在工作台中打开 in a panel's
+     * menu, the follow-up menu on a group, a panel's custom destination. No
+     * route, none of them — a panel that cross-filters still does. The
+     * `ViewHost`'s route when left out.
+     */
+    onNavigate?(to: ViewNavigation): void;
+    /**
+     * Whether the board is only read (off by default): nothing on it answers
+     * — no press on a group (no follow-up menu, no cross-filtering, no
+     * destination), no header sort or width handle on a record panel, no
+     * 「⋯」 on a panel, no retry on one that failed; the
+     * board re-runs on its own timer. An embed's static tier (D22, D36), a
+     * wall screen.
+     */
+    readOnly?: boolean;
+    /**
+     * Whether a panel's 「⋯」 offers 在工作台中打开 — the view behind it — when
+     * there is a route (on by default).
+     */
+    openInWorkbench?: boolean;
+    /**
+     * Whether a record panel's 「⋯」 offers 导出数据… — the export window over
+     * its rows (D14). On by default, and off by default on a board that is
+     * only read, which offers nothing unless told to: an embed's static
+     * tier with its export switched on has a 「⋯」 holding that item alone
+     * (D24 Q24).
+     */
+    panelExport?: boolean;
+    /** Whether panel titles are drawn (on by default; `DashboardPanel.titled`). */
+    panelTitles?: boolean;
+    /**
+     * How an embedding page offers each filter: a panel says nothing of a
+     * filter the page hid (「不受…影响」 would name what the reader cannot
+     * see).
+     */
+    filterModes?: BoardFilterModes;
+    className?: string;
+}
+export type { PanelHeadingLevel } from './DashboardPanel.js';
+/**
+ * The panels, placed.
+ *
+ * The grid library draws the gesture and nothing else: where a moved or
+ * resized panel lands, and what it pushes out of the way, is the kernel's
+ * (`useGridPlacement`), the drop reaches `dashboard.place`, which applies that
+ * placement alone, and everything inside a panel is the same component a
+ * full view would use.
+ *
+ * Only a gesture writes geometry back. The library also reports a layout it
+ * computed itself — on mount, and whenever the props change — and applying
+ * that would dirty a dashboard nobody touched, so those reports are not
+ * listened to. Panels sit where the config put them, not where a compactor
+ * would move them: the kernel admits `layout` as authored, and the screen
+ * must show what was admitted.
+ */
+export declare function DashboardGrid({ dashboard, editable, rowHeight, className, onRenderFailure, headingLevel, header, emptyActions, onNavigate: route, readOnly, openInWorkbench, panelExport, panelTitles, filterModes, }: DashboardGridProps): import('react').JSX.Element;
+//# sourceMappingURL=DashboardGrid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardGrid.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/DashboardGrid.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAuB,KAAK,SAAS,EAAY,MAAM,OAAO,CAAC;AAkBtE,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAY7D,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAO7B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AASrE,OAAO,EAAgB,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAUvE,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,mBAAmB,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC;;;;OAIG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC;;;;OAIG;IACH,MAAM,CAAC,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;IAC/C;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB;;;;;OAKG;IACH,UAAU,CAAC,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,EAC5B,SAAS,EACT,QAAgB,EAChB,SAAc,EACd,SAAS,EACT,eAAe,EACf,YAAgB,EAChB,MAAM,EACN,YAAY,EACZ,UAAU,EAAE,KAAK,EACjB,QAAgB,EAChB,eAAsB,EACtB,WAAuB,EACvB,WAAkB,EAClB,WAAW,GACZ,EAAE,kBAAkB,+BAiYpB"}

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

@@ -0,0 +1,143 @@
+import { ReactNode } from 'react';
+import { ArrangeStep } from '../../dashboard/index.js';
+import { DashboardPanelView } from '../../react/index.js';
+import { RecordPanelHost } from './PanelBodies.js';
+import { HandleMove } from '../kit/DragHandle.js';
+import { PanelCommands } from './commands.js';
+import { PanelPress } from './press.js';
+import { RenderFailureHandler } from '../kit/RenderBoundary.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/** Where a panel title may sit in a page's outline — never above a page title. */
+export type PanelHeadingLevel = 2 | 3 | 4 | 5 | 6;
+/**
+ * What a panel is called wherever it has to be named — its heading, its
+ * handles, the line that says where it landed.
+ *
+ * Its own title first. A view panel without one is named after the view it
+ * shows, which is what its reader sees in it; a heading after the words it
+ * says; a content panel after the kind of thing it holds. What is left — a
+ * panel whose view could not be opened —
+ * is named by where it stands on the board in reading order, counted from
+ * one (`index`). Never its id: `panel.id` is a key in a config, and
+ * 「orders-2」 is not a word anyone reading the board ever chose.
+ */
+export declare function panelName(panel: Pick<DashboardPanelView, 'title' | 'panel' | 'runtime'>, index: number, messages: MessageFormatters): string;
+/**
+ * Every panel's name by its id, each counted by its place in reading order
+ * — rows top to bottom, each left to right — which is the order the grid
+ * draws them in and the one a reader counts by.
+ *
+ * Two panels are never called the same by the board itself: a name the
+ * board made up (`panelName` without a title) that another panel already
+ * goes by is numbered in reading order — 「笔记」, 「笔记 2」 — so a handle,
+ * a finding or a landing announced by name points at one panel. Titles the
+ * author gave are theirs and left as they are, even when two agree; a
+ * made-up name steps around them.
+ */
+export declare function panelNames(panels: readonly DashboardPanelView[], messages: MessageFormatters): Map<string, string>;
+export interface DashboardPanelProps {
+    panel: DashboardPanelView;
+    editable?: boolean;
+    /**
+     * What the panel is called on screen; the grid names every panel once
+     * (`panelName`), counting an untitled one by its place among the others.
+     * Left out, the panel names itself the same way, as the first.
+     */
+    name?: string;
+    /** The title's heading level; `3`, under a workbench's `h2`, by default. */
+    headingLevel?: PanelHeadingLevel;
+    /**
+     * Whether the title is drawn (on by default). Off — an embed whose page
+     * says what each panel is (`withPanelTitles`) — the heading stays for a
+     * screen reader and the header row goes when nothing else is in it. A
+     * heading panel is its title, so it is drawn either way.
+     */
+    titled?: boolean;
+    /**
+     * One arrange command, when the layout may be edited; answers whether
+     * the panel moved (`arrangePanel` over the whole board had somewhere to
+     * put it).
+     */
+    onArrange?: (step: ArrangeStep) => boolean;
+    /** Takes back the last steps an arranging by keyboard took: its Escape. */
+    onArrangeCancel?: (steps: number) => void;
+    /**
+     * The handle the panel is carried along the one-column reading by, while
+     * the board is built (D22 J): where the panel stands in the column, how
+     * many there are, and the move. Left out everywhere else.
+     */
+    order?: {
+        index: number;
+        total: number;
+        onMove(move: HandleMove): void;
+    };
+    /**
+     * Re-runs this panel alone. Given, a panel whose query failed offers it
+     * as its retry (`DashboardController.refreshPanel`).
+     */
+    onRetry?: () => void;
+    /**
+     * Whether the body is only read (off by default): a record panel's
+     * headers neither sort nor resize — a static embed's board (D36), where
+     * nothing on the panel changes how it is looked at.
+     */
+    readOnly?: boolean;
+    /**
+     * What the panel's 「⋯」 menu offers (`panelCommands`); no menu without
+     * it, nor when it offers nothing.
+     */
+    commands?: PanelCommands;
+    /**
+     * The board's filters that hold a value and do not reach this panel, by
+     * their names on the bar (D22 F「不受此筛选影响」); said as a badge in the
+     * header, so nobody reads the panel as narrowed by them.
+     */
+    unreached?: readonly string[];
+    /**
+     * A filter wired to this panel whose control waits for a date, by its name
+     * on the bar: the body says to pick one rather than show the numbers of
+     * the value still in force (2026-09-26 review, P1-1).
+     */
+    awaiting?: string;
+    /** Under the body: the wiring strip while a filter is wired (D22 G). */
+    footer?: ReactNode;
+    /**
+     * The host's commands on a record panel (D39): its declared actions and
+     * slots, a row's and a selection's. Nothing on another kind of panel.
+     */
+    record?: RecordPanelHost;
+    /**
+     * What a press on one of the panel's groups does (D22 H, I); nothing on
+     * it is pressable without it.
+     */
+    press?: PanelPress;
+    /**
+     * The filter a press on this panel sets, by its name on the bar: said in
+     * the header (「点击筛选「仓库」」), so a reader knows a press filters the
+     * board rather than opening a menu.
+     */
+    pressesFilter?: string;
+    onRenderFailure?: RenderFailureHandler;
+    /**
+     * Told the height, in pixels, the panel needs to draw its body whole —
+     * a table's every row, a note's every line — and `0` where the body takes
+     * whatever room it is given (a chart). The grid grows a panel read on a
+     * board towards it (`fittedLayout`, P1-3).
+     */
+    onWhole?: (height: number) => void;
+}
+/**
+ * One framed panel: a title, its menu, the two arrange controls while the
+ * board is built, a body.
+ *
+ * The title is a heading, one level under whatever names the board — the
+ * view's own `h2` in a workbench (`ViewHeader`), the host's in an embed: a
+ * reader who moves through the page by headings reaches each panel by its
+ * name, which a styled `div` never let them do.
+ *
+ * A heading panel (`kind: 'heading'`) is that title and nothing else: a
+ * section's name across the board, set larger and on no body, since its
+ * words are already its title element (D22 A).
+ */
+export declare function DashboardPanel({ panel, editable, name: given, headingLevel, titled, onArrange, onArrangeCancel, order, onRetry, readOnly, commands, unreached, awaiting, footer, record, press, pressesFilter, onRenderFailure, onWhole, }: DashboardPanelProps): import('react').JSX.Element;
+//# sourceMappingURL=DashboardPanel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardPanel.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/DashboardPanel.tsx"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,93 @@
+import { DashboardContentPanel } from '../../model/index.js';
+import { PanelHeadingLevel } from './DashboardPanel.js';
+export interface ContentPanelProps {
+    panel: DashboardContentPanel;
+    /**
+     * The level of the heading that names the panel — a note's own headings
+     * sit under it (`MarkdownPanel.headingLevel`). `3`, a workbench panel's,
+     * by default.
+     */
+    headingLevel?: number;
+}
+/**
+ * The static panels: a note, a picture, a list of links.
+ *
+ * `validateDashboard` refuses anything but http, https, mailto and relative
+ * paths, and the grid keeps a panel it refused off the screen. These
+ * components check again anyway: they are exported on their own, so a host may
+ * render one from a config nothing admitted, and a guard that only runs
+ * somewhere else is not a guard. A URL that passes still says nothing about
+ * the resource behind it, so markdown renders without raw HTML, an image that
+ * fails to load shows a placeholder rather than a broken frame, and every link
+ * opens with `rel="noopener noreferrer"`.
+ */
+export declare function ContentPanel({ panel, headingLevel }: ContentPanelProps): import('react').JSX.Element;
+export interface HeadingPanelProps {
+    content: string;
+    /**
+     * The level of the heading the title is, for a host that uses it as a
+     * section's title: a reader moving by headings finds it in the outline.
+     * Without one it is a line of text, not a heading — the grid names a
+     * heading card by its panel title instead, so it passes none.
+     */
+    headingLevel?: PanelHeadingLevel;
+}
+/**
+ * A section's title across the board: one line of plain text, cut short
+ * rather than wrapped, since a heading card is one row high. Plain text on
+ * purpose — no markdown, no link — so a title is never anything else. On a
+ * board the grid draws a heading card as its panel title alone
+ * (`DashboardPanel`), at the level of every other panel title; this is the
+ * same words for a host that renders a content panel by itself.
+ */
+export declare function HeadingPanel({ content, headingLevel }: HeadingPanelProps): import('react').JSX.Element;
+export interface MarkdownPanelProps {
+    content: string;
+    /**
+     * The level of the heading that names the panel: the note's `#` is one
+     * under it, its `##` two, never past `h6` (U-12). A note's `#` drawn as
+     * an `h1` sat above the page's own title in the outline, and a reader
+     * moving by headings took it for a new page. `3` by default.
+     */
+    headingLevel?: number;
+}
+/** Markdown with raw HTML left off, which is the whole point of using it. */
+export declare function MarkdownPanel({ content, headingLevel, }: MarkdownPanelProps): import('react').JSX.Element;
+export interface ImagePanelProps {
+    src: string;
+    alt?: string;
+    fit?: 'contain' | 'cover';
+    href?: string;
+    /**
+     * The panel's title, which names the link when the picture has no `alt`
+     * of its own to name it with.
+     */
+    title?: string;
+}
+export declare function ImagePanel({ src, alt: givenAlt, fit, href, title: givenTitle, }: ImagePanelProps): import('react').JSX.Element;
+export interface LinksPanelProps {
+    items: readonly {
+        label: string;
+        href: string;
+        description?: string;
+    }[];
+}
+/**
+ * A list of links, one `Item` per line (decisions.md D16-3).
+ *
+ * A label with a sentence under it is exactly what `Item` draws, so the two
+ * hand-written lines — an `<a>` with its own hover rules and a `<p>` under
+ * it — are `ItemTitle` and `ItemDescription` now.
+ *
+ * **The anchor stays around the label, not around the row.** Making the
+ * whole `Item` the link is the registry's own shape (`[a]:hover:bg-muted`),
+ * and it would grow the target from the words to the line — but a link's
+ * accessible name is the text inside it, so the author's sentence would be
+ * read out as part of the link's name on every one of them. A bigger target
+ * is not worth a name that recites its own description.
+ *
+ * The `<ul>` stays around the rows as well: `ItemGroup` says `role="list"`
+ * over `div`s, and a list of links is a real list.
+ */
+export declare function LinksPanel({ items }: LinksPanelProps): import('react').JSX.Element;
+//# sourceMappingURL=DashboardPanels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardPanels.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/DashboardPanels.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAUlE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAK7D,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,qBAAqB,CAAC;IAC7B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,iBAAiB,+BAqBtE;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,iBAAiB,+BAYxE;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAqGD,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,EAC5B,OAAO,EACP,YAAgB,GACjB,EAAE,kBAAkB,+BAiBpB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,UAAU,CAAC,EACzB,GAAG,EACH,GAAG,EAAE,QAAQ,EACb,GAAe,EACf,IAAI,EACJ,KAAK,EAAE,UAAU,GAClB,EAAE,eAAe,+BAiEjB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACzE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,EAAE,eAAe,+BAyCpD"}

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

@@ -0,0 +1,43 @@
+import { ReactNode } from 'react';
+import { DashboardTab } from '../../model/index.js';
+import { DashboardController } from '../../react/index.js';
+import { DashboardEditing } from '../../runtime/index.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+export interface DashboardTabsProps {
+    dashboard: DashboardController;
+    /**
+     * The board's edits, while it is being built: the bar then adds, renames,
+     * reorders and deletes tabs. Left out, it only switches between them.
+     */
+    editing?: DashboardEditing | null;
+    /** Told when the reader picks a tab — the workbench remembers it. */
+    onShow?(tabId: string): void;
+    /**
+     * A control of the surface's own at the end of the tabs' row, read — an
+     * embed's 「铺满屏幕」 when neither a first row nor a filter bar is there
+     * to hold it (D10). It is not a tab, so it stands beside the `tablist`.
+     */
+    end?: ReactNode;
+}
+/**
+ * A board's tabs (D22 E): a bar over the grid — under the edit bar while the
+ * board is built — drawn only when there are two or more; one tab reads as
+ * none. The global filter stays above it, since it applies to every tab.
+ * Pressing a tab shows it (`DashboardController.showTab`): the grid draws
+ * that tab's panels alone, and only they run. The workbench hands it to the
+ * board as `DashboardEditExtensions.tabBar`; an embed draws it as the
+ * grid's header.
+ *
+ * While the board is being built the bar is the tabs to arrange: a way to
+ * add a tab (on a board with one or none, the only thing on the bar), and
+ * for each tab a handle to carry it — its arrows move it too — the press
+ * that shows it, and a menu to rename it in place, move it, or delete it; a
+ * tab that carries panels is asked about first. A `tablist` holds tabs and
+ * nothing else, so that bar is a list, as every sortable list here is.
+ * Nothing here writes anything: every edit is the board's draft, and
+ * finishing the edit is what saves it.
+ */
+export declare function DashboardTabs({ dashboard, editing, onShow, end, }: DashboardTabsProps): import('react').JSX.Element | null;
+/** What a tab is called on the bar: its title, else its place. */
+export declare function tabTitle(tab: DashboardTab, index: number, messages: MessageFormatters): string;
+//# sourceMappingURL=DashboardTabs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DashboardTabs.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/DashboardTabs.tsx"],"names":[],"mappings":"AAaA,OAAO,EAA+B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,4BAA4B,CAAC;AAKpC,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,mBAAmB,CAAC;IAC/B;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAClC,qEAAqE;IACrE,MAAM,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B;;;;OAIG;IACH,GAAG,CAAC,EAAE,SAAS,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,EAC5B,SAAS,EACT,OAAO,EACP,MAAM,EACN,GAAG,GACJ,EAAE,kBAAkB,sCAuLpB;AAED,kEAAkE;AAClE,wBAAgB,QAAQ,CACtB,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,CAIR"}

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

@@ -0,0 +1,55 @@
+import { ReactNode, RefObject } from 'react';
+import { ViewInstance } from '../../model/index.js';
+import { SaveCommands } from '../../react/index.js';
+import { AddCommands } from './AddMenu.js';
+import { BoardHistory } from './history.js';
+export interface EditBarProps extends AddCommands {
+    commands: SaveCommands;
+    /** The board's title, which the shared-save question names. */
+    title: string;
+    /** The one-column reading: building there is renaming, removing and reordering (D22 J). */
+    narrow: boolean;
+    /** Leaves the building state; the board is then read as saved. */
+    onLeave(): void;
+    /** Told of the instance a 保存 wrote, as a save from the title bar tells. */
+    onSaved?(instance: ViewInstance): void;
+    /** The bar's own name, where the keyboard lands when nothing else on the bar can take it. */
+    landingRef: RefObject<HTMLParagraphElement | null>;
+    /** 「＋ 添加」, where the keyboard returns after an add from a dialog. */
+    addRef: RefObject<HTMLButtonElement | null>;
+    /** 「添加筛选」 beside 「＋ 添加」 (D22 G); a placement it is not, so narrow too. */
+    addFilter?: ReactNode;
+    /** 固定宽度／全宽 (D31) after them; one column has no width to see, so not narrow. */
+    width?: ReactNode;
+    /** 撤销 and 重做 (`useBoardHistory`), narrow too: every edit there is one. */
+    history: BoardHistory;
+    undoRef: RefObject<HTMLButtonElement | null>;
+    redoRef: RefObject<HTMLButtonElement | null>;
+}
+/**
+ * The bar a board is built under (D22 A): 「正在编辑」 and what that means,
+ * 撤销／重做 (one step of building each), 「＋ 添加 ▾」, and the two ways out — 取消 puts back the saved board, 保存
+ * saves it the way the title bar's Save does and leaves.
+ *
+ * 保存 is that save, not a second one: a shared board asks first, as Save
+ * does (the question names the board, #1836); a board never saved asks for
+ * its name and audience; and a write that did not land keeps the bar up,
+ * with what became of it said under the title as ever (`WriteOutcome`).
+ * Nothing to save is nothing to ask — 保存 just leaves.
+ *
+ * 取消 asks before it throws edits away, in the words ↺ uses for the same
+ * loss; a board never saved has nothing to go back to, so it has no 取消 —
+ * 保存 or leaving the view are the ways out.
+ *
+ * It stays in view while the board is built (R3b), as Metabase's does: an
+ * added panel is scrolled to, and the ways out must not scroll away with the
+ * top of the board. So it sticks to the top of whatever scrolls the board —
+ * the page, or a host's scrolling box — over the panels sliding beneath it,
+ * which is why its fill is the muted wash made opaque (`bg-row-hover`, the
+ * same shade the band has at rest) rather than the wash itself, and why it
+ * carries a rem of the board's ground (the canvas) above it: the workbench
+ * scrolls a padded box, and a sticky edge stops at the padding, not at the
+ * box's edge.
+ */
+export declare function EditBar({ commands, title, narrow, onLeave, onSaved, landingRef, addRef, add, canCreate, addFilter, width, history, undoRef, redoRef, }: EditBarProps): import('react').JSX.Element;
+//# sourceMappingURL=EditBar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EditBar.d.ts","sourceRoot":"","sources":["../../../src/ui/dashboard/EditBar.tsx"],"names":[],"mappings":"AAaA,OAAO,EAA2B,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEhF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAYzD,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAGvE,MAAM,WAAW,YAAa,SAAQ,WAAW;IAC/C,QAAQ,EAAE,YAAY,CAAC;IACvB,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,2FAA2F;IAC3F,MAAM,EAAE,OAAO,CAAC;IAChB,kEAAkE;IAClE,OAAO,IAAI,IAAI,CAAC;IAChB,2EAA2E;IAC3E,OAAO,CAAC,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IACvC,6FAA6F;IAC7F,UAAU,EAAE,SAAS,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IACnD,qEAAqE;IACrE,MAAM,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC5C,0EAA0E;IAC1E,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,+EAA+E;IAC/E,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,0EAA0E;IAC1E,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC7C,OAAO,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CAAC,EACtB,QAAQ,EACR,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,UAAU,EACV,MAAM,EACN,GAAG,EACH,SAAS,EACT,SAAS,EACT,KAAK,EACL,OAAO,EACP,OAAO,EACP,OAAO,GACR,EAAE,YAAY,+BAgKd"}