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

package/dist/ui/workbench/ResultBlock.d.ts

@@ -0,0 +1,88 @@
+import { ReactNode } from 'react';
+import { WorkbenchShellProps } from './WorkbenchShell.js';
+export interface ResultBlockContents {
+    /** Whether the block would be the framed one. */
+    framed: boolean;
+    /** Whether a result is on screen for it to hold. */
+    hasResult: boolean;
+    /** Whether a request is on its way, which the rows are drawn loading for. */
+    pending: boolean;
+    /** Whether the strips slot will actually draw something. */
+    strips: boolean;
+    /** Whether the kind's own result slot will actually draw something. */
+    result: boolean;
+}
+/**
+ * Whether there is a result block at all.
+ *
+ * A frame is a frame **round a result**, so it waits for one: a config the
+ * definition refuses never ran, so there is no result and nothing on its
+ * way, and the frame drawn round the toolbar alone was an empty result —
+ * ruled off, captioned, and with Export still pressable over nothing
+ * (F-14). What the reader is owed in that state is the error above it and
+ * the way to fix it, which is where both now are. A query that failed keeps
+ * the frame: the strip is what the block holds, and it is about the rows.
+ *
+ * An unframed block draws no frame and so has no empty frame to avoid: it
+ * is the kind's own stack, and a dashboard's grid of panels is its result
+ * whether a panel has answered yet or not — an editable board with nothing
+ * on it is where panels are added from.
+ */
+export declare function resultBlockShown({ framed, hasResult, pending, strips, result, }: ResultBlockContents): boolean;
+/**
+ * The result and its caption, on no card of their own (D12).
+ *
+ * **The frame knows the four parts it holds, not what they are made of** —
+ * a toolbar first, the strips under it, the kind's result, and the caption
+ * row that ends it. It used to style five children by descendant selector,
+ * three of them slots only a record view has, so the frame all three kinds
+ * share carried one kind's furniture by name; D18-1 puts the record and
+ * analysis workbenches behind one shell in phase 2, and that shell is meant
+ * to grow no `if` per kind. What stays here is the chrome of the two slots
+ * the shell itself fills (`ui/kit/variants.tsx`'s `resultFrameChrome` — the
+ * toolbar as the first row, a callout's margin); the rest each kind hands
+ * in through `slots`, as the recipe `resultSlots()` gave it.
+ *
+ * The card used to be here for every kind but the dashboard, and it was a
+ * frame around a frame in all of them: a table draws its own header layer,
+ * its own hairlines between rows and its own edges on the held columns, so a
+ * border and 12px of padding around that put the first row of data behind
+ * five layers of chrome. Without it the table runs to the block's edge and
+ * the lines on screen are the table's own, which is the only set of lines
+ * that means anything. A dashboard still opts out (`resultFramed={false}`
+ * on the shell): its result is already a grid of cards, and a frame round
+ * that would be the card of cards the rule forbids.
+ */
+export declare function ResultBlock({ framed, slots, children, }: {
+    framed: boolean;
+    /**
+     * What this kind's own parts wear inside the frame, from
+     * `resultSlots()`. Nothing given is a frame that dresses only the two
+     * slots the shell fills — which is the whole of an analysis view's, and
+     * of the skeleton that stands in for one that is opening.
+     */
+    slots?: string;
+    children: ReactNode;
+}): import('react').JSX.Element;
+export interface ShellResultProps extends Pick<WorkbenchShellProps, 'toolbar' | 'result' | 'onRenderFailure'> {
+    framed: boolean;
+    /** The kind's slot recipe, as `ResultBlock.slots` takes it. */
+    slots?: string;
+    /** The strip between the toolbar and the rows, as the shell resolved it. */
+    strip: ReactNode;
+    /** What resets both boundaries: the open view. */
+    resetKeys: readonly unknown[];
+}
+/**
+ * The result block as the shell fills it: the toolbar, the strip and the
+ * kind's result, in that order.
+ *
+ * The host's bulk slot renders in the toolbar and its row slot in the rows,
+ * so both are held: a throwing one takes the bar or the rows, and the title
+ * bar, the editor and the draft stay. Two boundaries rather than one so that
+ * the half that still works still draws — and the strip between them is
+ * neither's, because a query that failed has to be readable whatever the
+ * host's buttons did.
+ */
+export declare function ShellResult({ framed, slots, toolbar, strip, result, resetKeys, onRenderFailure, }: ShellResultProps): import('react').JSX.Element;
+//# sourceMappingURL=ResultBlock.d.ts.map

package/dist/ui/workbench/ResultBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResultBlock.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/ResultBlock.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAKvC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,MAAM,EAAE,OAAO,CAAC;IAChB,oDAAoD;IACpD,SAAS,EAAE,OAAO,CAAC;IACnB,6EAA6E;IAC7E,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,MAAM,EAAE,OAAO,CAAC;IAChB,uEAAuE;IACvE,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,MAAM,EACN,SAAS,EACT,OAAO,EACP,MAAM,EACN,MAAM,GACP,EAAE,mBAAmB,GAAG,OAAO,CAG/B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,EAC1B,MAAM,EACN,KAAK,EACL,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,SAAS,CAAC;CACrB,+BAiBA;AAED,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAC5C,mBAAmB,EACnB,SAAS,GAAG,QAAQ,GAAG,iBAAiB,CACzC;IACC,MAAM,EAAE,OAAO,CAAC;IAChB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,KAAK,EAAE,SAAS,CAAC;IACjB,kDAAkD;IAClD,SAAS,EAAE,SAAS,OAAO,EAAE,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,EAC1B,MAAM,EACN,KAAK,EACL,OAAO,EACP,KAAK,EACL,MAAM,EACN,SAAS,EACT,eAAe,GAChB,EAAE,gBAAgB,+BAoBlB"}

package/dist/ui/workbench/ResultToolbar.d.ts

@@ -0,0 +1,109 @@
+import { FieldDefinition, FieldGroupDefinition } from '../../model/index.js';
+import { RecordTableController } from '../../react/index.js';
+import { RecordViewRuntime } from '../../runtime/index.js';
+import { ReleasedPins } from '../record/pinCap.js';
+import { ExportWindowProps } from '../kit/ExportDialog.js';
+import { WorkbenchFeatures } from '../kit/features.js';
+import { SelectionContext } from '../record/SelectionBar.js';
+import type * as React from 'react';
+export interface ResultToolbarProps {
+    table: RecordTableController;
+    /**
+     * How this view is renewed: the one-shot refresh, and the interval it
+     * keeps itself up to date by. It comes from the workbench rather than off
+     * the table controller because `refresh.interval` belongs to every kind of
+     * view (`ViewConfigBase`), not to a table.
+     */
+    /** Fields the definition offers, for the column picker. */
+    fields: readonly FieldDefinition[];
+    /** The picker groups of the definition the fields come from. */
+    fieldGroups?: readonly FieldGroupDefinition[];
+    /**
+     * The field holding each row's identity. The column settings hold it on
+     * the left, where the table shows it, and let nothing past it.
+     */
+    rowKey?: string;
+    /** Pins the table's cap is not drawing right now (D17-4). */
+    released?: ReleasedPins;
+    /**
+     * What is offered for the rows that are selected: the declared actions
+     * over a selection, then the host's bulk slot. It is a render function
+     * rather than a node, because it acts on the selection and the toolbar
+     * is what knows the selection.
+     */
+    bulkActions?(context: SelectionContext): React.ReactNode;
+    /**
+     * Taking the result away, when the surface offers it (`useExportOffer`):
+     * the controller, the columns and the ceiling, plus the two things only the
+     * workbench can say — the conditions the rows came back under, and what the
+     * file will be called. They are here because the
+     * export window says what the file will hold **before** it is made (D14),
+     * and neither of those is readable off a table controller.
+     *
+     * An embedded view that offers no export simply passes none, and the
+     * button is not there.
+     *
+     * The button also waits for something to export (`table.hasResult`): a
+     * query that failed leaves the frame standing — the strip in it is about
+     * the rows — and Export in that bar was a control over nothing, which
+     * P-17 answers by absence rather than by a disabled button (D4).
+     */
+    exporter?: ExportWindowProps;
+    /**
+     * Which of the toolbar's own controls are there at all (D18 XI). Every one
+     * by default; one turned off is absent, not disabled. The export button
+     * follows `exporter` rather than this — a surface that offers no export
+     * passes none.
+     */
+    features?: WorkbenchFeatures;
+    /**
+     * The runtime behind the controller, which the toolbar hands to `bulkActions`,
+     * whose actions are commands against the view they act in.
+     */
+    runtime: RecordViewRuntime;
+}
+/**
+ * The bar above the result: what is selected on the left, how the result is
+ * shown on the right.
+ *
+ * **It is a `Toolbar`, not a row of buttons that looks like one.** Base UI's
+ * primitive (`ui/kit/toolbar.tsx`; the registry carries no `toolbar`) makes the
+ * whole bar one tab stop with the arrows moving inside it, and writes the
+ * `role` and `aria-orientation` that used to be missing. On a wide record
+ * view this was eight or nine stops between the rows and everything above
+ * them. The layout switch needs nothing said about it: Base UI's own
+ * `ToggleGroup` is toolbar-aware — inside one it draws a plain `role=group`
+ * and its segments register with the bar's roving order rather than opening
+ * a second one. The two grouped functions keep `ButtonGroup`, which is what
+ * draws their shared seam; `Toolbar.Group`'s only behaviour beyond the
+ * `role="group"` both give is disabling a whole group at once, which nothing
+ * here does.
+ *
+ * Layout and column changes are edits to the view — they make it dirty and,
+ * once saved, come back with it. The selection is not: it lives for one
+ * opening, which is why nothing here reaches a saved config. Paging sits
+ * below the result in `RecordPagination`, where the rows it pages are.
+ *
+ * The right is three groups by responsibility, 8px apart and seamless
+ * inside: the layout switch, then how the table shows what it has, then how
+ * fresh it is. Every control here is `ghost` — the toolbar sits above the
+ * result and must not compete with it — except the layout switch, which
+ * wears one outline because that outline is what makes it read as one
+ * control with two positions rather than two buttons. The host's bulk
+ * actions are the only `outline` in the row, and the one primary button on
+ * screen stays the filter's Apply.
+ *
+ * **The three right-hand groups wrap together, as one block.** They used to
+ * be siblings of a `flex-1` spacer, and a spacer is the worst thing to wrap
+ * around: it took a full line of its own width, pushed the layout switch to
+ * the far right of the first line by itself, dropped the arrange group to
+ * the left of the second and the refresh split button to a third — three
+ * rows of 104px at a phone's width, and still three at 768px. Sitting in one
+ * `ml-auto ... justify-end` box, they stay a block that ends where the bar
+ * ends, and the selection keeps the left. 768px is one line now; 375px with
+ * a selection is still three, because 406px of controls does not go into a
+ * 317px bar however it wraps — but they are three grouped lines rather than
+ * three scattered ones.
+ */
+export declare function ResultToolbar({ table, fields, fieldGroups, rowKey, released, bulkActions, exporter, features, runtime, }: ResultToolbarProps): React.JSX.Element;
+//# sourceMappingURL=ResultToolbar.d.ts.map

package/dist/ui/workbench/ResultToolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResultToolbar.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/ResultToolbar.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EAErB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAQhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE9E,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAKxE,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,qBAAqB,CAAC;IAC7B;;;;;OAKG;IACH,2DAA2D;IAC3D,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IACnC,gEAAgE;IAChE,WAAW,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC9C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;;OAKG;IACH,WAAW,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,KAAK,CAAC,SAAS,CAAC;IACzD;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B;;;OAGG;IACH,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,MAAM,EACN,WAAW,EACX,MAAM,EACN,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,GACR,EAAE,kBAAkB,qBAkMpB"}

package/dist/ui/workbench/SaveActions.d.ts

@@ -0,0 +1,76 @@
+import { SaveCommands } from '../../react/index.js';
+import { ViewWriteCallbacks } from './WriteOutcome.js';
+import { FinalFocus } from '../kit/focus.js';
+/**
+ * Two of the group, and only two: this button group saves and copies, so
+ * those are the two landings it can report. Renaming and deleting are the
+ * view manager's, and a recovered write is reported by the line that offered
+ * the recovery — `WriteOutcome`, where {@link ViewWriteCallbacks} is
+ * declared. The whole group used to be threaded through here as well, three
+ * props of it never read: a host wiring `onDeleted` to this component would
+ * have waited for a call that could not come.
+ */
+export interface SaveActionsProps extends Pick<ViewWriteCallbacks, 'onSaved' | 'onCreated'> {
+    commands: SaveCommands;
+    title: string;
+    /**
+     * Whether a save in place is offered only while something is unsaved: a
+     * view whose edits are made and saved in a building state of its own — a
+     * dashboard, whose edit bar holds 「保存」 (D32). Read with nothing to
+     * save, such a view's save in place could only ever be a disabled button
+     * beside its primary 「编辑」, so the group is the copy alone.
+     */
+    copyWhenClean?: boolean;
+}
+/**
+ * Saving the open view: one button for the thing to do now, and a menu for
+ * the rest.
+ *
+ * Which button that is, is decided by permission rather than by state: a view
+ * the user may write to saves, one they may not copies, and a view they can
+ * do neither to shows no group at all. Nothing here is a disabled button for
+ * a permission the user does not hold — a control that can never be pressed
+ * teaches nothing and costs a click to find out.
+ *
+ * Commands resolve rather than reject, so nothing here is wrapped in a
+ * try/catch: an outcome that needs a decision lands in `commands.state` and
+ * `WriteOutcome` keeps it on screen until the user answers it.
+ */
+export declare function SaveActions({ commands, title, onSaved, onCreated, copyWhenClean, }: SaveActionsProps): import('react').JSX.Element | null;
+/**
+ * 「这会更新所有人看到的「X」」: the one question before a shared view is
+ * written over. An `AlertDialog`, as every confirmation here is: Base UI
+ * holds it open under a stray click and keeps focus on the two answers.
+ * Not destructive in tone — nothing is lost that the author did not mean
+ * to change — but said, because the people it changes for are not here.
+ */
+export declare function SharedSaveConfirm({ open, title, onOpenChange, onConfirm, finalFocus, }: {
+    open: boolean;
+    title: string;
+    onOpenChange(open: boolean): void;
+    onConfirm(): void;
+    /** Where the keyboard goes as it closes (`FinalFocus`); Base UI's choice when left out. */
+    finalFocus?: FinalFocus;
+}): import('react').JSX.Element;
+/**
+ * The "edited" mark, with the way back on it.
+ *
+ * Revert used to be the second item of the Save menu — two presses deep,
+ * under a chevron, for the one command that answers the state this mark
+ * announces. The user's call (2026-09-21): the command belongs beside the
+ * fact it undoes. So the mark is the word and, when the saved config can be
+ * put back, one icon button after it, named and tooltipped «Revert»; a
+ * never-saved view has nothing to go back to and shows the word alone
+ * (`ViewHeader` draws that one). The Save menu keeps only Save as.
+ */
+export declare function UnsavedMark({ commands, lookOnly, }: {
+    commands: SaveCommands;
+    /**
+     * Whether only how the result is drawn differs from what was saved
+     * (`presentationOnlyEdits`, D23 Q15): the mark says 「只改了展示」, since
+     * switching 表格｜图表 is a reader changing how they look, and a bare
+     * 「已修改」 read as a question edited.
+     */
+    lookOnly?: boolean;
+}): import('react').JSX.Element;
+//# sourceMappingURL=SaveActions.d.ts.map

package/dist/ui/workbench/SaveActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaveActions.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/SaveActions.tsx"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AA0BzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,EAAY,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAQ5D;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAC5C,kBAAkB,EAClB,SAAS,GAAG,WAAW,CACxB;IACC,QAAQ,EAAE,YAAY,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,KAAK,EACL,OAAO,EACP,SAAS,EACT,aAAqB,GACtB,EAAE,gBAAgB,sCAoOlB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,KAAK,EACL,YAAY,EACZ,SAAS,EACT,UAAU,GACX,EAAE;IACD,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,SAAS,IAAI,IAAI,CAAC;IAClB,2FAA2F;IAC3F,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,+BAmCA;AA6DD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,QAAgB,GACjB,EAAE;IACD,QAAQ,EAAE,YAAY,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,+BAsCA"}

package/dist/ui/workbench/SaveAsDialog.d.ts

@@ -0,0 +1,66 @@
+import { ViewInstance, ViewScope } from '../../model/index.js';
+import { SaveAbilities, SaveCommands, SaveCommandState } from '../../react/index.js';
+import { FinalFocus } from '../kit/focus.js';
+/**
+ * What the form needs of the save commands: which audiences a create may go
+ * to, whether a write is out and what the last one said, and the create
+ * itself. The open view's `SaveCommands` are one; a dashboard saving a view
+ * it owns as a view of its own (D22 C) hands in another.
+ */
+export interface SaveAsCommands {
+    /**
+     * `createSystem` adds the system audience to the choices (D81); left out,
+     * it is not offered.
+     */
+    can: Pick<SaveAbilities, 'createPersonal' | 'createShared'> & Partial<Pick<SaveAbilities, 'createSystem'>>;
+    state: Pick<SaveCommandState, 'pending' | 'error'>;
+    saveAs: SaveCommands['saveAs'];
+}
+export interface SaveAsDialogProps {
+    open: boolean;
+    onOpenChange(open: boolean): void;
+    commands: SaveAsCommands;
+    /** The view being copied; the title field opens on `{title} copy`. */
+    title: string;
+    /**
+     * What the create is: a copy of a saved view, or the first save of one
+     * made from nothing. The form is the same — a title and an audience — and
+     * only its words change: a first save opens on the view's own name rather
+     * than on "{title} copy", and its heading says "save" rather than "copy".
+     * A `promote` is a dashboard's own analysis saved as a view (D22 C): it
+     * opens on the panel's name, and `description` says what it becomes. A
+     * `share` is the personal view a shared board's panel stands on, copied
+     * for the board's readers (D22 B): it opens on the view's own name — the
+     * copy lands in the shared group, apart from the original, and a panel
+     * named after its view keeps its name on the board — and asks no
+     * audience, since shared is the whole point. A `share-system` is the
+     * same on a system board (D81): the copy is a system view.
+     */
+    intent?: 'copy' | 'first' | 'promote' | 'share' | 'share-system';
+    /** The sentence under the heading, where the intent's own does not say enough. */
+    description?: string;
+    /**
+     * The audience picked at first; the user's own when they may make one. A
+     * system board's panel opens on `system` where it is granted (D81).
+     */
+    defaultScope?: ViewScope;
+    /** Called with the copy once the store took it. */
+    onSaved?(instance: ViewInstance): void;
+    /**
+     * Where the keyboard goes as it closes (`FinalFocus`): the control that
+     * asked — a menu's trigger, since the item that was pressed went with the
+     * menu. Base UI's own choice when left out.
+     */
+    finalFocus?: FinalFocus;
+}
+/**
+ * Making a copy of the open view: a title and who it is for.
+ *
+ * It is one dialog used from two places — the save menu, and the copy way out
+ * of a conflict — because both ask the same question and both must answer it
+ * the same way. The dialog stays open until the store has actually taken the
+ * copy: a create that was refused has something to say, and a dialog that
+ * closed first would say it somewhere the user is no longer looking.
+ */
+export declare function SaveAsDialog({ open, onOpenChange, commands, title, intent, description, defaultScope, onSaved, finalFocus, }: SaveAsDialogProps): import('react').JSX.Element;
+//# sourceMappingURL=SaveAsDialog.d.ts.map

package/dist/ui/workbench/SaveAsDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaveAsDialog.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/SaveAsDialog.tsx"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,SAAS,EACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AA0B9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,GAAG,EAAE,IAAI,CAAC,aAAa,EAAE,gBAAgB,GAAG,cAAc,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CAAC;IAC/C,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,GAAG,OAAO,CAAC,CAAC;IACnD,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,cAAc,CAAC;IACjE,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,mDAAmD;IACnD,OAAO,CAAC,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IACvC;;;;OAIG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AA4ED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,MAAe,EACf,WAAW,EACX,YAAY,EACZ,OAAO,EACP,UAAU,GACX,EAAE,iBAAiB,+BAmBnB"}

package/dist/ui/workbench/SearchBox.d.ts

@@ -0,0 +1,18 @@
+import { SearchBoxController } from '../../react/index.js';
+/**
+ * The view's search, at the end of the applied band — beside the conditions
+ * it is one of (`useSearchBox`).
+ *
+ * Typing edits the draft, as any condition does, so the editor's pending
+ * count moves with it; Enter puts it in force — not each keystroke, since
+ * each would be a query over the whole store, and not while an input
+ * method is composing, whose Enter picks a candidate rather than asking
+ * (`isPlainEnter`). ✕ takes the search away and asks again, because the
+ * rows on screen were found by it. The box is named by the search field's
+ * own label — 「搜索错误」 says what is searched, 「搜索」 would not — and
+ * what Enter does is said once, to a screen reader, in its description.
+ */
+export declare function SearchBox({ search }: {
+    search: SearchBoxController;
+}): import('react').JSX.Element;
+//# sourceMappingURL=SearchBox.d.ts.map

package/dist/ui/workbench/SearchBox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchBox.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/SearchBox.tsx"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAWhE;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,+BA8CpE"}

package/dist/ui/workbench/Sidebar.d.ts

@@ -0,0 +1,50 @@
+import { ReactNode, RefObject } from 'react';
+import { ViewListProps } from './ViewList.js';
+import { ViewSwitcherProps } from './ViewSwitcher.js';
+export interface SidebarColumnProps extends Omit<ViewListProps, 'onRetry'> {
+    /**
+     * What stands in the column in place of the list while it is given — the
+     * shell's `panel` slot, read as React reads a child. It shows whether or
+     * not the list is folded.
+     */
+    panel?: ReactNode;
+    /**
+     * The surface is too narrow for a column beside the view
+     * (`useNarrowSurface`): the panel is drawn in a drawer over the page
+     * rather than as a block on top of the result.
+     */
+    narrow?: boolean;
+    /** The drawer was dismissed — Escape, a press outside, its close button. */
+    onPanelClose?(): void;
+    /** Whether the list is beside the view rather than folded away. */
+    open: boolean;
+}
+/**
+ * The column beside the view: the visualization panel while one is given
+ * (D20 屏 I), otherwise the view list while the sidebar is open, otherwise
+ * nothing — the folded list lives in the title bar as `FoldedSidebar`.
+ *
+ * On a narrow surface there is no column beside anything: the shell stacks,
+ * and the panel stood on top of the result it configures — ten tiles and a
+ * button, a phone's whole first screen, with the chart pushed below it
+ * (2026-09-23 audit). There it is the registry's sheet from the bottom edge
+ * (the drawer position), over the page, the result's top still in view
+ * above it; dismissing it is the panel's own way back.
+ */
+export declare function SidebarColumn({ panel, narrow, onPanelClose, open, list, ...rest }: SidebarColumnProps): import('react').JSX.Element;
+export interface FoldedSidebarProps extends ViewSwitcherProps {
+    /** The definition's title, which the folded list leaves in the bar. */
+    title?: string;
+    /** The unfold button, focused when collapsing took the list away. */
+    expandRef: RefObject<HTMLButtonElement | null>;
+    /** A press of the unfold button. */
+    onExpand(): void;
+}
+/**
+ * What the sidebar leaves in the title bar while it is folded away: the way
+ * back to the list, the definition's name and the list itself as one control.
+ * Both exist only while the sidebar is away — with it on screen, the list
+ * *is* the switcher and the sidebar's heading is the definition's title.
+ */
+export declare function FoldedSidebar({ title, expandRef, onExpand, ...switcher }: FoldedSidebarProps): import('react').JSX.Element;
+//# sourceMappingURL=Sidebar.d.ts.map

package/dist/ui/workbench/Sidebar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sidebar.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/Sidebar.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAU,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAM/D,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAIzE,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC;IACxE;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,4EAA4E;IAC5E,YAAY,CAAC,IAAI,IAAI,CAAC;IACtB,mEAAmE;IACnE,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,MAAc,EACd,YAAY,EACZ,IAAI,EACJ,IAAI,EACJ,GAAG,IAAI,EACR,EAAE,kBAAkB,+BA4EpB;AAED,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;IAC3D,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,SAAS,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC/C,oCAAoC;IACpC,QAAQ,IAAI,IAAI,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,SAAS,EACT,QAAQ,EACR,GAAG,QAAQ,EACZ,EAAE,kBAAkB,+BA2EpB"}

package/dist/ui/workbench/StatusLine.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from 'react';
+import { ViewKind } from '../../model/index.js';
+import { WorkbenchController } from '../../react/index.js';
+import { WorkbenchShellProps } from './WorkbenchShell.js';
+export interface StatusLineProps extends Pick<WorkbenchShellProps, 'warnings' | 'besideResult' | 'nameIssue'> {
+    /** The way out of an error, already resolved against the editor's fold. */
+    errorAction?: ReactNode;
+    /** The filter's unmarked findings, the definition's and the list's. */
+    workbench: WorkbenchController;
+    /** The open view, whose findings and result are the rest of it. */
+    state: NonNullable<WorkbenchController['state']>;
+    /** The kind on screen, which names the error strip's title. */
+    kind: ViewKind | undefined;
+    /**
+     * Whether the condition editor is off screen — folded away, or not drawn
+     * at all — so no pill shows the findings marked on it.
+     */
+    conditionsHidden?: boolean;
+    /** Unfolds the condition editor; left out where there is none to show. */
+    onShowConditions?(): void;
+}
+/**
+ * The status line (D12 Ⅰ′): what the view reports about itself, under the
+ * title bar and only when there is something to say — a config that will
+ * not run, a warning that does not block. The last write's outcome is the
+ * title bar's own line above. `empty:hidden` keeps the row out of the flow
+ * when every strip rendered nothing, so the ruler's 16px does not stack
+ * twice.
+ */
+export declare function StatusLine({ workbench, state, kind, warnings, errorAction, besideResult, nameIssue: named, conditionsHidden, onShowConditions, }: StatusLineProps): import('react').JSX.Element;
+//# sourceMappingURL=StatusLine.d.ts.map

package/dist/ui/workbench/StatusLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StatusLine.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/StatusLine.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAS,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAkB,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAahF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAC3C,mBAAmB,EACnB,UAAU,GAAG,cAAc,GAAG,WAAW,CAC1C;IACC,2EAA2E;IAC3E,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,uEAAuE;IACvE,SAAS,EAAE,mBAAmB,CAAC;IAC/B,mEAAmE;IACnE,KAAK,EAAE,WAAW,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC;IACjD,+DAA+D;IAC/D,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC3B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,0EAA0E;IAC1E,gBAAgB,CAAC,IAAI,IAAI,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EACzB,SAAS,EACT,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,WAAW,EACX,YAAY,EACZ,SAAS,EAAE,KAAe,EAC1B,gBAAwB,EACxB,gBAAgB,GACjB,EAAE,eAAe,+BAyJjB"}

package/dist/ui/workbench/TitleBar.d.ts

@@ -0,0 +1,39 @@
+import { ReactNode, RefObject } from 'react';
+import { ViewKind } from '../../model/index.js';
+import { WorkbenchController } from '../../react/index.js';
+import { ViewExpansion } from '../kit/ViewExpansion.js';
+import { ViewHeaderState } from './ViewHeader.js';
+import { WorkbenchShellProps } from './WorkbenchShell.js';
+export interface TitleBarProps extends Pick<WorkbenchShellProps, 'actions' | 'freshness' | 'editorModes' | 'onRenderFailure' | 'build' | 'commitElsewhere'> {
+    /** The commands, the refresh and the write callbacks the bar is drawn from. */
+    workbench: WorkbenchController;
+    state: ViewHeaderState;
+    kind: ViewKind;
+    titleId: string;
+    titleRef: RefObject<HTMLHeadingElement | null>;
+    /** What resets the actions' boundary: the open view. */
+    resetKeys: readonly unknown[];
+    /** Whether the bar names the view itself — not while `leading` does. */
+    namesView: boolean;
+    /** What the folded sidebar leaves at the head of the identity group. */
+    leading?: ReactNode;
+    /** The editor fold's toggle name; given only when the editor folds. */
+    editorLabel?: string;
+    editorPending: number;
+    /** Whether the view's own query is running, for the default refresh. */
+    busy: boolean;
+    /** Whether the workbench offers to fill the screen at all. */
+    expandable: boolean;
+    fill: ViewExpansion;
+    expandViewRef: RefObject<HTMLButtonElement | null>;
+    /** A save-as created a view: the shell sends focus to its title. */
+    onCreated(): void;
+}
+/**
+ * The title bar's block: a banner, ruled off rather than boxed — a card
+ * around the thing that names the page is a card around the page. The
+ * identity group on the left is `ViewHeader`'s; the right-hand group is the
+ * view-level controls this block assembles.
+ */
+export declare function TitleBar({ workbench, state, kind, titleId, titleRef, actions, resetKeys, onRenderFailure, namesView, leading, editorLabel, editorModes, editorPending, freshness, busy, expandable, fill, expandViewRef, onCreated, build, commitElsewhere, }: TitleBarProps): import('react').JSX.Element;
+//# sourceMappingURL=TitleBar.d.ts.map

package/dist/ui/workbench/TitleBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TitleBar.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/TitleBar.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAIhE,OAAO,EAAoB,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,EAAc,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,MAAM,WAAW,aAAc,SAAQ,IAAI,CACzC,mBAAmB,EACjB,SAAS,GACT,WAAW,GACX,aAAa,GACb,iBAAiB,GACjB,OAAO,GACP,iBAAiB,CACpB;IACC,+EAA+E;IAC/E,SAAS,EAAE,mBAAmB,CAAC;IAC/B,KAAK,EAAE,eAAe,CAAC;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;IAC/C,wDAAwD;IACxD,SAAS,EAAE,SAAS,OAAO,EAAE,CAAC;IAC9B,wEAAwE;IACxE,SAAS,EAAE,OAAO,CAAC;IACnB,wEAAwE;IACxE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,IAAI,EAAE,OAAO,CAAC;IACd,8DAA8D;IAC9D,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACnD,oEAAoE;IACpE,SAAS,IAAI,IAAI,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,EACvB,SAAS,EACT,KAAK,EACL,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,OAAO,EACP,SAAS,EACT,eAAe,EACf,SAAS,EACT,OAAO,EACP,WAAW,EACX,WAAW,EACX,aAAa,EACb,SAAS,EACT,IAAI,EACJ,UAAU,EACV,IAAI,EACJ,aAAa,EACb,SAAS,EACT,KAAK,EACL,eAAe,GAChB,EAAE,aAAa,+BAmEf"}

package/dist/ui/workbench/Unopenable.d.ts

@@ -0,0 +1,19 @@
+import { Issue } from '../../model/index.js';
+/**
+ * What a surface shows when the chosen view cannot be opened: the reason,
+ * and the ways on — trying again, where the failure may pass
+ * (`retryableOpen`), and the default. The workbenches' main column and both
+ * embeds draw it, so a view a reader cannot open looks the same wherever it
+ * is (second review R2-80).
+ *
+ * Neutral, not destructive: nothing broke, the view is simply not
+ * available here. A view the reader has no right to wears a lock, and its
+ * reason says who can change that; the reason is said by its code
+ * (`data-issue`).
+ */
+export declare function Unopenable({ issue, onRetry, onDefault, }: {
+    issue: Issue;
+    onRetry?(): void;
+    onDefault?(): void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=Unopenable.d.ts.map

package/dist/ui/workbench/Unopenable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Unopenable.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/Unopenable.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAgBlD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,OAAO,EACP,SAAS,GACV,EAAE;IACD,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,CAAC,IAAI,IAAI,CAAC;IACjB,SAAS,CAAC,IAAI,IAAI,CAAC;CACpB,+BAqCA"}

package/dist/ui/workbench/ViewEngineProvider.d.ts

@@ -0,0 +1,93 @@
+import { ReactNode } from 'react';
+import { ViewEngine, ViewNavigation } from '../../runtime/index.js';
+import { RecordDetailControl } from '../../react/index.js';
+import { ViewMessages } from '../kit/messages.js';
+import { ViewBinding } from './bindings.js';
+import { ViewDestination, ViewRouter } from '../../runtime/routes.js';
+export interface ViewEngineProviderProps {
+    /**
+     * The application's engine, built once (host-integration.md 4); an inner
+     * provider without one uses the outer one's. The engine's definitions
+     * are said where they are shown, in the wording in force there (`useSay`),
+     * so a provider nested in another language says them in its words as it
+     * says the engine's own messages. The words of the outermost provider
+     * that names the engine are the ones checked for keys they lack
+     * (`ViewEngine.setText`).
+     */
+    engine?: ViewEngine;
+    /**
+     * The language values are shown in; the outer provider's when left out.
+     * A change of it redraws what is open and rebuilds nothing.
+     */
+    locale?: string;
+    /**
+     * Wording, merged over what is already in force — the engine's own and
+     * the definitions' keys (`text(key)`) alike: every label a definition
+     * carries is said in these words where it is shown, so switching them
+     * redraws every open view in them without reopening, re-querying or
+     * dirtying anything (3.1).
+     */
+    messages?: ViewMessages;
+    /**
+     * The host's route: every way off a board or a view — 在工作台中打开, a
+     * follow-up on a group, a panel's destination, the way back to a board —
+     * reaches it through the route of the definition it leads to
+     * (`ViewBindingOptions.route`) as a `ViewRoute`; a URL, and a definition
+     * with no route, reach it as they came.
+     */
+    navigate?(to: ViewDestination): void;
+    /**
+     * Each definition's behaviour in this host (`bind`); an inner one wins by
+     * id.
+     */
+    bindings?: readonly ViewBinding[];
+    /** The host's router; the outer provider's when left out. */
+    router?: ViewRouter;
+    /** The record open in the address; the outer provider's when left out. */
+    detail?: RecordDetailControl;
+    /** Set by `ViewHost`: what is under it has a host above. */
+    hosted?: boolean;
+    children: ReactNode;
+}
+/**
+ * The engine, its words and its bindings, for every surface under it
+ * (host-integration.md 4) — `ViewHost`'s inside, not an entry of its own
+ * (4.2): one engine for the application, so a surface
+ * takes only what differs where it stands — `<DataWorkbench
+ * definitionId={ORDERS} />`. Providers nest, the inner one over the outer
+ * one; a surface's own `engine`, `messages`, `locale` or `onNavigate` still
+ * wins, so a page with two engines is as easy to write as before.
+ *
+ * The definitions keep their keys, and every surface under it says them in
+ * the wording in force where it shows them (`useSay`): a change of
+ * `messages` or `locale` redraws what is open in the new words — the same
+ * runtimes, no query run again. The provider that names an engine checks
+ * its words for the keys they lack (`ViewEngine.setText`).
+ */
+export declare function ViewEngineProvider({ engine: own, locale, messages, navigate, bindings, router, detail, hosted, children, }: ViewEngineProviderProps): import('react').JSX.Element;
+/**
+ * The engine a surface draws: its own, else its provider's. A surface with
+ * neither is a host's mistake, said as one.
+ *
+ * A host's own component under a `ViewHost` reads the one engine here too —
+ * a record's reading that asks a resource's source of its own
+ * (`engine.resolveSource`), say — rather than having it threaded down.
+ */
+export declare function useEngine(own?: ViewEngine): ViewEngine;
+/**
+ * The route a surface hands its ways off: its own, else its provider's,
+ * each target resolved through the route of the definition it leads to,
+ * as the nearest provider binds it.
+ */
+export declare function useRoutedNavigate(own?: (to: ViewNavigation) => void): ((to: ViewNavigation) => void) | undefined;
+/**
+ * What the host bound to a definition (`bind`), from the providers above.
+ * Under a router, a bound resource's record detail follows the address
+ * (`?id=`) where its `reading` holds no open record of its own.
+ */
+export declare function useBindings(): (definitionId: string) => ViewBinding | undefined;
+/** The host's router, from the `ViewHost` above; `undefined` without one. */
+export declare function useViewRouter(): ViewRouter | undefined;
+/** Whether a `ViewHost` is above. */
+export declare function useHosted(): boolean;
+//# sourceMappingURL=ViewEngineProvider.d.ts.map