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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ViewEngineProvider.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/ViewEngineProvider.tsx"],"names":[],"mappings":"AAaA,OAAO,EAML,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAOhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,UAAU,EAChB,MAAM,yBAAyB,CAAC;AAiCjC,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAClC,6DAA6D;IAC7D,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,4DAA4D;IAC5D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,MAAM,EAAE,GAAG,EACX,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,MAAM,EACN,QAAQ,GACT,EAAE,uBAAuB,+BA0DzB;AAyBD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,UAAU,CAQtD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,IAAI,GACjC,CAAC,CAAC,EAAE,EAAE,cAAc,KAAK,IAAI,CAAC,GAAG,SAAS,CAU5C;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,CAC7B,YAAY,EAAE,MAAM,KACjB,WAAW,GAAG,SAAS,CAmB3B;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,IAAI,UAAU,GAAG,SAAS,CAEtD;AAED,qCAAqC;AACrC,wBAAgB,SAAS,IAAI,OAAO,CAEnC"}

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

@@ -0,0 +1,123 @@
+import { ReactNode, RefObject } from 'react';
+import { ViewConfig, ViewKind } from '../../model/index.js';
+import { ViewRuntimeState } from '../../runtime/index.js';
+import { SaveCommands } from '../../react/index.js';
+import { ViewWriteCallbacks } from './WriteOutcome.js';
+/**
+ * What a title bar reads off the open view. It names the four facts rather
+ * than the whole snapshot, so one header serves every kind of view: nothing
+ * here is record-shaped, analysis-shaped or dashboard-shaped.
+ */
+export type ViewHeaderState = Pick<ViewRuntimeState<ViewConfig>, 'title' | 'scope' | 'saved' | 'dirty' | 'draft'>;
+/**
+ * The bar passes the write callbacks through rather than declaring its own:
+ * they are {@link ViewWriteCallbacks}, and the components underneath here —
+ * the button group and the outcome line — are what call them.
+ */
+export interface ViewHeaderProps extends ViewWriteCallbacks {
+    /** Null while no view is open; the bar then renders nothing. */
+    state: ViewHeaderState | null;
+    kind: ViewKind;
+    commands: SaveCommands;
+    /** The host's own global actions, rendered left of the save commands. */
+    actions?: ReactNode;
+    /**
+     * Anything the surface needs at the very start of the line, before the
+     * kind icon: what a collapsed sidebar leaves behind, for instance. It is
+     * empty by default, and the bar makes no room for it when it is.
+     */
+    leading?: ReactNode;
+    /**
+     * The view-level controls of the right-hand group — the editor's fold,
+     * and in time whatever else governs how this view is being looked at.
+     * They come before the host's own actions, which end the controls.
+     */
+    trailing?: ReactNode;
+    /**
+     * The way into building the view — a dashboard's 「编辑」 (D22 A), the
+     * primary button of the view being read — drawn last on the line, after
+     * the host's actions (D32). Where it is offered, a save in place belongs
+     * to the building, so while nothing is unsaved the save commands offer a
+     * copy alone. Absent where the view is not built here.
+     */
+    build?: ReactNode;
+    /**
+     * Whether the view is committed and rolled back somewhere other than this
+     * bar — a dashboard being built, whose edit bar holds 「保存」 and
+     * 「取消」 (D22 A). The bar then leaves off its save commands and the
+     * "edited" mark with its ↺: one way to do one thing, and a second Save or
+     * a second revert beside the edit bar's would be the same command under
+     * another name.
+     */
+    commitElsewhere?: boolean;
+    /**
+     * Whether this bar is the thing that says which view is open. False when
+     * something in `leading` already does — a view switcher shows the kind and
+     * the title both — and the bar then drops its own icon and leaves the
+     * title as a heading a screen reader still reaches but nobody sees twice.
+     */
+    namesView?: boolean;
+    /**
+     * The id the view title carries, so the region the view is drawn in can
+     * name itself by it. One is generated when the caller has nothing to point
+     * at it.
+     */
+    titleId?: string;
+    /**
+     * Where the view title sits in the document outline. It is a heading
+     * rather than a line of text because it names everything under it, and a
+     * screen reader navigates by headings; the level is the host's, since only
+     * the page around the workbench knows what it is nested in.
+     */
+    headingLevel?: HeadingLevel;
+    /**
+     * A handle on the title heading, for a host that has to put focus on the
+     * view itself — after a copy is created and opened, for one. It is a ref
+     * rather than a lookup by `titleId`, because the element belongs to this
+     * component and a caller should not have to go into the document for it.
+     */
+    titleRef?: RefObject<HTMLHeadingElement | null>;
+}
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * The one line that says which view this is, and the one place it is saved
+ * from.
+ *
+ * Three facts sit on the left and none repeats another: which kind of view it
+ * is, who it is for, and what it is called. The fourth — whether what is on
+ * screen has been saved — is a mark beside the title rather than a state the
+ * save button has to be read to discover. What became of the last write goes
+ * underneath, where it can be a line of text instead of a banner over the
+ * result.
+ */
+export declare function ViewHeader({ state, kind, commands, onSaved, onCreated, onRenamed, onDeleted, onRecovered, actions, leading, trailing, build, commitElsewhere, namesView, titleId, headingLevel, titleRef, }: ViewHeaderProps): import('react').JSX.Element | null;
+export interface RevertDialogProps {
+    open: boolean;
+    onOpenChange(open: boolean): void;
+    /** Puts the saved config back; only the confirming answer calls it. */
+    onConfirm(): void;
+    /**
+     * Where focus goes once the edits are gone. The button that opened this is
+     * inside the "edited" mark, and the mark is what reverting takes off the
+     * bar — so on the way out there is nothing to give focus back to, and the
+     * view's own heading is the nearest thing to where the user was standing.
+     */
+    landing: RefObject<HTMLElement | null>;
+}
+/**
+ * The question in front of ↺.
+ *
+ * It is the leave guard's question about the same draft, so it is the leave
+ * guard's shape: an `AlertDialog` (the edits are lost for good, so an
+ * outside click must not be an answer), one sentence for what it costs, the
+ * answer that stays first and the destructive one last, named after the
+ * command it carries out rather than after the dialog.
+ *
+ * Asked rather than undone, because there is no undo to offer: a runtime can
+ * put the *saved* config back and nothing else, so an "Undone · Undo" strip
+ * would need a way to restore an arbitrary draft that does not exist. A
+ * dialog in front of an action that could be taken back is friction; in
+ * front of one that cannot, it is the only place the user gets to decide.
+ */
+export declare function RevertDialog({ open, onOpenChange, onConfirm, landing, }: RevertDialogProps): import('react').JSX.Element;
+//# sourceMappingURL=ViewHeader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ViewHeader.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/ViewHeader.tsx"],"names":[],"mappings":"AAaA,OAAO,EAKL,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,QAAQ,EACd,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAgBzD,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG1E;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,gBAAgB,CAAC,UAAU,CAAC,EAC5B,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAChD,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACzD,gEAAgE;IAChE,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC;IACvB,yEAAyE;IACzE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;CACjD;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,SAAS,EACT,SAAS,EACT,SAAS,EACT,WAAW,EACX,OAAO,EACP,OAAO,EACP,QAAQ,EACR,KAAK,EACL,eAAuB,EACvB,SAAgB,EAChB,OAAO,EACP,YAAgB,EAChB,QAAQ,GACT,EAAE,eAAe,sCA0RjB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,uEAAuE;IACvE,SAAS,IAAI,IAAI,CAAC;IAClB;;;;;OAKG;IACH,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,YAAY,EACZ,SAAS,EACT,OAAO,GACR,EAAE,iBAAiB,+BA6CnB"}

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

@@ -0,0 +1,71 @@
+import { RefObject } from 'react';
+import { ViewListState } from '../../react/index.js';
+import { NewViewCommand } from './NewView.js';
+export interface ViewListProps {
+    list: ViewListState;
+    /**
+     * What this list is a list of — the definition's own title. It is the
+     * definition's to say rather than the list's, so a workbench reads it off
+     * `engine.definitions` and passes it; the list renders it because the
+     * heading is also what names the `nav` to a screen reader.
+     */
+    title?: string;
+    currentId: string | null;
+    onOpen(instanceId: string): void;
+    /**
+     * Makes a view from nothing. Given one, the heading grows the `+` D12
+     * puts there; left out — no permission, or nothing behind it — it does
+     * not exist (D4). The empty line below it says nothing about creating:
+     * the offer is made once, in the room the new view will fill.
+     */
+    /** Makes a view; absent when none may be made here (D4). */
+    create?: NewViewCommand;
+    /**
+     * Reads the list again after it failed. The failure is said where the
+     * missing rows would be — under the views that are there, or in place of
+     * them — with this beside it; without it the sentence stands alone.
+     */
+    onRetry?(): void;
+    /**
+     * Opens the view manager — renaming, deleting, reordering and the default
+     * view. Given one, the heading grows a button for it; left out, the list is
+     * a list. The dialog itself is not the list's: the header offers the same
+     * way in while the list is collapsed away, and two entries onto two dialogs
+     * would be two dialogs, so whoever draws both holds the open state.
+     */
+    onManage?(): void;
+    /**
+     * Folds the list away. Given one, the heading grows the button that does
+     * it; left out, the list cannot be collapsed and says so by having no
+     * control for it.
+     */
+    onCollapse?(): void;
+    /**
+     * The collapse button itself, so whoever owns the state can put focus on
+     * the control that undoes what it just did. Expanding lands here; the
+     * button that expands lives in the title bar and is held there.
+     */
+    collapseRef?: RefObject<HTMLButtonElement | null>;
+}
+/**
+ * The views of one definition, grouped by who they are for, in the user's
+ * own order within each group.
+ *
+ * It is a **navigation column and not a panel**: it paints its own grey
+ * ground and rules itself off from the work area, so a glance says which
+ * side of the screen is the list and which side is the view. Everything
+ * inside then has one ground to stand out from — the open view is the work
+ * area's own white on it, hover is a step the other way, and neither can be
+ * read as the other.
+ *
+ * Three facts share one row and none of them repeats another: the icon says
+ * which kind of view it is, because one data definition holds record and
+ * analysis views together; the group heading says who it is for; and the
+ * lock at the row's end says it came with the definition. A system view is
+ * a shared view — that is `audienceOf`'s answer, not a third group.
+ *
+ * A system view is always here even when the store is unreachable, because it
+ * travels with the definition rather than with the data.
+ */
+export declare function ViewList({ list, title, currentId, onOpen, create, onRetry, onManage, onCollapse, collapseRef, }: ViewListProps): import('react').JSX.Element;
+//# sourceMappingURL=ViewList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ViewList.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/ViewList.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAe9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAM1D,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAWnE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,aAAa,CAAC;IACpB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC;;;;;OAKG;IACH,4DAA4D;IAC5D,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,IAAI,IAAI,CAAC;IACjB;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,IAAI,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,IAAI,IAAI,CAAC;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,EACvB,IAAI,EACJ,KAAK,EACL,SAAS,EACT,MAAM,EACN,MAAM,EACN,OAAO,EACP,QAAQ,EACR,UAAU,EACV,WAAW,GACZ,EAAE,aAAa,+BA+Gf"}

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

@@ -0,0 +1,49 @@
+import { ViewKind } from '../../model/index.js';
+import { ViewListState } from '../../react/index.js';
+import { NewViewCommand } from './NewView.js';
+export interface ViewSwitcherProps {
+    /** The same list the sidebar draws, already narrowed to the kinds drawn. */
+    list: ViewListState;
+    /**
+     * The face the trigger wears: the open view's kind, or the one kind a
+     * workbench draws while nothing is open yet. A workbench of several kinds
+     * with nothing open has no face to show, and the trigger shows none.
+     */
+    kind?: ViewKind;
+    /** The open view, checked in the menu; null while none is. */
+    currentId: string | null;
+    /**
+     * The open view's title, on the trigger. Empty where there is no open view
+     * to name — the screen that reports one which will not open, and the moment
+     * before the first one arrives — and the trigger then says what it is for
+     * instead of showing nothing.
+     */
+    currentTitle: string;
+    onOpen(instanceId: string): void;
+    /**
+     * Makes a view from nothing: the sidebar's `+`, in the one control that
+     * stands in for the sidebar. Absent when nothing is behind it (D4).
+     */
+    create?: NewViewCommand;
+    /**
+     * Opens the view manager. The item is absent when it is left out, which is
+     * how a user with no write permission at all is spared an entry whose only
+     * lesson is that it leads to a dialog of read-only rows.
+     */
+    onManage?(): void;
+}
+/**
+ * The view list as one control, for when there is no room for the list.
+ *
+ * It is the sidebar's job done in a header's worth of space: the same views,
+ * the same two groups in the same order, the same tag on the ones that ship
+ * with the definition. Only one of them is ever on screen — collapsing the
+ * sidebar is what puts this here — so nothing about which view is open is
+ * ever said twice.
+ *
+ * Choosing goes out through the same `choose` the sidebar calls, so the
+ * leave guard still asks before a draft is released: the shortcut is a
+ * shorter way to the same door, not a way around it.
+ */
+export declare function ViewSwitcher({ list, kind, currentId, currentTitle, onOpen, create, onManage, }: ViewSwitcherProps): import('react').JSX.Element;
+//# sourceMappingURL=ViewSwitcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ViewSwitcher.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/ViewSwitcher.tsx"],"names":[],"mappings":"AAcA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAiB1D,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAGhE,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,IAAI,EAAE,aAAa,CAAC;IACpB;;;;OAIG;IACH,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC;;;OAGG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,MAAM,EACN,MAAM,EACN,QAAQ,GACT,EAAE,iBAAiB,+BAyInB"}

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

@@ -0,0 +1,291 @@
+import { ReactNode } from 'react';
+import { Issue } from '../../model/index.js';
+import { WorkbenchController } from '../../react/index.js';
+import { RenderFailureHandler } from '../kit/RenderBoundary.js';
+import { ViewMessages } from '../kit/messages.js';
+import { ViewSurfaceProps, ViewTheme } from '../kit/ViewSurface.js';
+import { ViewDensity, ViewPreset } from '../kit/presets.js';
+/**
+ * The landmark the work column is (Q64): `main`, the page's main content, or
+ * a named `region` for a host whose own `<main>` the workbench stands in —
+ * a page has one `main`, and one inside another is no longer top level.
+ */
+export type WorkbenchLandmark = 'main' | 'region';
+export interface WorkbenchShellProps {
+    workbench: WorkbenchController;
+    /** The definition's title, which names the sidebar and the header. */
+    title?: string;
+    /** The mode, as `ViewSurface` takes it: follows the host when left out. */
+    theme?: ViewTheme;
+    /** A preset pinned on the surface and its popups (`ViewSurface`). */
+    preset?: ViewPreset;
+    /** How dense the tables, the view list and the panels sit (`ViewSurface`). */
+    density?: ViewDensity;
+    /**
+     * The host's own `--fve-*` for this surface and its popups alone
+     * (`ViewSurface`): beats any preset, the one pinned here included.
+     */
+    tokens?: ViewSurfaceProps['tokens'];
+    /** Wording, merged over what is already in force: where a host translates. */
+    messages?: ViewMessages;
+    /**
+     * The language dates and times show in; the runtime's when left out. It is
+     * the same choice as `messages`, made for values rather than words.
+     */
+    locale?: string;
+    /**
+     * The zone times show in — the engine's, so a row's time reads on the same
+     * clock a relative condition was filtered by.
+     */
+    timeZone?: string;
+    /** The clock "now" is read from — the engine's `environment`. */
+    clock?: ViewSurfaceProps['clock'];
+    /** The host's own global actions, at the end of the right-hand group. */
+    actions?: ReactNode;
+    /**
+     * How this view is renewed, as the last of the view-level controls. Left
+     * out, the shell draws the refresh control from `workbench.refresh`, busy
+     * while the view's own query runs; a dashboard passes its own, because
+     * its panels are what run and what the note beside the control names.
+     */
+    freshness?: ReactNode;
+    /**
+     * The way into building the view, beside its save commands on the title
+     * bar — a dashboard's 「编辑」 (D22 A).
+     */
+    build?: ReactNode;
+    /**
+     * The view is saved and reverted elsewhere: the title bar leaves off its
+     * save commands and the "edited" mark's ↺ — see `ViewHeader`.
+     */
+    commitElsewhere?: boolean;
+    /** The view's own editor, between the title bar and the strips. */
+    editor?: ReactNode;
+    /**
+     * The view's search box (`SearchBox`), at the end of the applied band: the
+     * one condition kept on hand rather than in the fold, beside the
+     * conditions the rows were fetched under.
+     */
+    search?: ReactNode;
+    /**
+     * What the editor is called. Given one, the editor lives in a fold whose
+     * toggle sits in the title bar; left out, the editor is drawn open on its
+     * own block. It is opt-in because only a view whose editor *has* a settled
+     * shape can fold it — `docs/design/decisions.md` Q2 leaves the analysis
+     * editor's form open, so that workbench passes none.
+     */
+    editorLabel?: string;
+    /**
+     * Menu items for a chevron beside the editor's toggle: the ways of
+     * editing this editor offers. Left out, the toggle stands alone.
+     */
+    editorModes?: ReactNode;
+    /** Controlled fold state; the shell holds its own when left out. */
+    editorOpen?: boolean;
+    /**
+     * The fold a view opens on. A view that was never saved opens out — there
+     * is nothing to look at until it has been told what to ask for — and a
+     * saved one opens folded, because its author already decided.
+     */
+    defaultEditorOpen?: boolean;
+    onEditorOpenChange?(open: boolean): void;
+    /**
+     * How many nodes of the editor say something other than what ran. The
+     * toggle carries the dot and the count, so the one credential for
+     * "edited, not applied" survives the editor being folded away.
+     */
+    editorPending?: number;
+    /**
+     * The result block's first row (D12 Ⅳ): what may be done to the result
+     * and how it is shown. It is its own slot rather than the head of
+     * `result` because the failure strip goes between the two — the toolbar
+     * is the block's first row whatever else the block holds, and a red line
+     * above it read as a banner over the whole view rather than as something
+     * the rows below had to say.
+     */
+    toolbar?: ReactNode;
+    /**
+     * The strip between the toolbar and the rows. Left out, the shell draws
+     * the query strip from the view's own query — failed, stale or not, retry
+     * — which is what a record and an analysis view both say there; a
+     * dashboard, whose panels fail one by one, passes `null`.
+     */
+    strips?: ReactNode;
+    /** The rows, the chart, the panels — what the page is for. */
+    result?: ReactNode;
+    /**
+     * The way out of an error the status line reports, at the end of its
+     * line. A record view offers its column settings, an analysis view its
+     * tray or its chart options. Given as a function, it is asked whether the
+     * editor is open: a way out that only opens the editor is no way out
+     * while the editor is already open under it (2026-09-23 audit).
+     */
+    errorAction?: ReactNode | ((editorOpen: boolean) => ReactNode);
+    /**
+     * The codes of the findings a result makes about itself that the kind
+     * draws beside that result — an analysis's 「只显示了前 N 组」 over its
+     * table — and that the status line therefore leaves out, so a sentence is
+     * said once and where it is about.
+     */
+    besideResult?: readonly string[];
+    /**
+     * The sidebar a workbench opens on. One boolean governs it, so collapsing
+     * is a change in one place rather than in the layout of every part beside
+     * it. It is view state and nothing else: never saved, never asked about by
+     * the leave guard.
+     *
+     * Left out, the shell decides from the room it was actually given and
+     * keeps deciding as that room changes (`useSidebarFold`): a column
+     * narrower than `md` folds, because below that width the list is not
+     * beside the view but stacked on top of it, and 204px of navigation above
+     * the first row is the worst trade a phone can make. Once the user has
+     * pressed the fold themselves, their answer stands. A host that says
+     * `true` or `false` is obeyed at every width and never measured — it knows
+     * something about its page that a measurement does not.
+     */
+    defaultSidebarOpen?: boolean;
+    /** Told whenever the sidebar opens or closes, for a host that mirrors it. */
+    onSidebarOpenChange?(open: boolean): void;
+    /**
+     * Whether the workbench offers to fill the screen. It is the same kind of
+     * state as the sidebar's fold — this screen at this moment, never saved,
+     * never asked about by the leave guard — so the shell holds it; the host
+     * only says whether the control is there at all. A page that is already a
+     * full-screen view of one thing has nothing to gain from it.
+     */
+    expandable?: boolean;
+    /**
+     * Whether the view manager is on offer at all (D18 XI). On by default;
+     * off, neither the sidebar's gear nor the switcher's item exists. What
+     * the user may do inside it is the store's permissions, read separately.
+     */
+    manage?: boolean;
+    /**
+     * Whether the result below was ever asked for; the applied bar renders
+     * nothing until it was. The open view's own result when left out — a
+     * dashboard has none of its own and answers from its panels instead.
+     */
+    hasResult?: boolean;
+    /**
+     * Whether the applied-conditions band is drawn. On by default; a
+     * dashboard turns it off (D27): its filters run as they change, so its
+     * filter bar is what the panels are showing, its fixed scope read there.
+     */
+    applied?: boolean;
+    /**
+     * Whether a request is on its way, which is the other reason a result
+     * block exists before there is a result: the rows are drawn loading in
+     * it. The open view's own query when left out.
+     */
+    resultPending?: boolean;
+    /**
+     * The warnings to show. Left out, every one the view reports, plus what
+     * this result says about itself (`resultIssues`): a summary row that fell
+     * back to the page, a grouping that filled its limit, are facts about the
+     * numbers below, and they outlive the next keystroke because they ride
+     * with the result rather than with the draft's admission.
+     */
+    warnings?: readonly Issue[];
+    /**
+     * How a finding is said in the status line, where it stands away from the
+     * part it is about. A dashboard names the panel a finding belongs to —
+     * 「这个面板」 means something inside a panel and nothing above the grid.
+     * Every finding is said as it is when left out.
+     */
+    nameIssue?(issue: Issue): Issue;
+    /**
+     * Whether the result is drawn inside one frame — toolbar on top, rows to
+     * the edge, pagination at the bottom (D12). A dashboard opts out: its
+     * result is already a grid of cards, and a frame round cards is a frame
+     * round frames.
+     */
+    resultFramed?: boolean;
+    /**
+     * What this kind's own parts wear inside that frame, from `resultSlots()`
+     * (`ui/kit/variants.tsx`). The shell dresses the two slots it fills itself —
+     * the toolbar as the frame's first row, a strip's margin — and carries
+     * this through untouched: which of a kind's parts is the caption row and
+     * which keeps the frame's padding is the kind's to say, not the shell's
+     * (D18-1 — one shell, no `if` per kind).
+     */
+    resultSlots?: string;
+    /**
+     * Whether the kind's result has something to say before anything was
+     * asked: a record view on a source that wants a condition first (Q3)
+     * draws its 「先添加一个条件」 where the rows would be.
+     */
+    resultWithoutQuery?: boolean;
+    /**
+     * Where a render failure caught by one of the shell's boundaries goes —
+     * the host's own action slot, the editor or the result. The part shows a
+     * recoverable error state in place either way; this is how the host
+     * learns of it.
+     */
+    onRenderFailure?: RenderFailureHandler;
+    /**
+     * What stands in the sidebar column in place of the view list while it is
+     * given: the visualization panel (D20 屏 I). The list is navigation, and
+     * navigation is not needed while a chart is being configured, so the one
+     * column serves both — the panel carries its own way back. It shows
+     * whether or not the list is folded.
+     *
+     * Read as React reads a child, so `open && <Panel />` is the way a part
+     * says "not now": every other slot is filled that way, and a column held
+     * open by a `false` would take the list off the screen for good.
+     */
+    panel?: ReactNode;
+    /**
+     * The panel was dismissed as a drawer — on a surface too narrow for a
+     * column beside the view it is drawn as one (`SidebarColumn`).
+     */
+    onPanelClose?(): void;
+    /**
+     * The landmark the work column is (Q64). `main` by default: a workbench is
+     * usually what the page is for. A host that already draws its own `<main>`
+     * and places the workbench inside it says `region`, and the column is a
+     * `<section>` named as `main` would be — by the open view's title, or by
+     * the definition's while none is open. Nothing else changes: the layout
+     * reads the column by its slot, never by its tag.
+     */
+    landmark?: WorkbenchLandmark;
+    /** Extra classes for the main column. */
+    className?: string;
+}
+/**
+ * The frame the three default workbenches share: the view list beside it, the
+ * title bar over it, the findings under that, and the two slots that make one
+ * kind different from another.
+ *
+ * The main column is **blocks**, not a stack of rows: the title bar as a
+ * banner ruled off from what follows, the status line, the conditions in a
+ * tray, the band of applied conditions, and the result — which sits on no
+ * card at all (D12), because a table draws its own header layer, its own
+ * hairlines and its own held edges, and a border round that is a frame
+ * round a frame. The blocks are what make grouping visible — when the space
+ * between two blocks is the space between two buttons, nothing reads as
+ * belonging to anything — which is why every distance comes from one scale
+ * (`layout.ts`) rather than from whatever looked right at each call site.
+ *
+ * Within that, the order is by how close each part stands to the result:
+ * which view this is, the editor folded out of the way, anything the view has
+ * to say in a line, what the result was fetched under, then the result.
+ *
+ * The title bar reads as two groups and nothing crosses between them: on the
+ * left, everything about *which view this is* — the way back to the list, the
+ * view's name and the commands that save it; on the right, everything about
+ * *how it is being looked at* — the editor's fold and the host's own actions.
+ *
+ * Almost everything the shell draws it reads from one `WorkbenchController`.
+ * The two exceptions are the two things that are neither the view nor the
+ * list: whether the sidebar is folded away, and whether the editor is. Both
+ * belong to this screen at this moment — nothing about them is worth saving,
+ * and the leave guard has nothing to ask about them — so the shell holds them
+ * rather than handing every workbench the same two `useState` calls.
+ *
+ * The shell composes its columns and blocks rather than drawing them: the
+ * sidebar in its two forms, the title bar, the status line, the condition
+ * tray and the filled result block are `workbench/`'s, and what stays here
+ * is the state they share and the order they stand in.
+ */
+export declare function WorkbenchShell({ workbench, title, theme, preset, density, tokens, messages: wording, locale, timeZone, clock, actions, freshness, build, commitElsewhere, editor, editorLabel, search, editorModes, editorOpen, defaultEditorOpen, onEditorOpenChange, editorPending, toolbar, strips, result, errorAction, besideResult, defaultSidebarOpen, onSidebarOpenChange, expandable, manage, hasResult, applied, resultPending, warnings, nameIssue, onRenderFailure, resultFramed, resultSlots, resultWithoutQuery, panel, onPanelClose, landmark, className, }: WorkbenchShellProps): import('react').JSX.Element;
+//# sourceMappingURL=WorkbenchShell.d.ts.map

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

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

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

@@ -0,0 +1,51 @@
+import { ViewInstance } from '../../model/index.js';
+import { WriteAction } from '../../runtime/index.js';
+import { SaveCommands } from '../../react/index.js';
+/**
+ * What a host is told about the writes of one open view.
+ *
+ * Declared here, once, because this is the component that calls them: a
+ * write's outcome is where a save, a rename or a delete is finally reported
+ * from, whether it landed the first time or was recovered afterwards. The
+ * title bar passes the group through, and a component that reports only part
+ * of it picks that part out of this type rather than restating it — a prop a
+ * component never calls is a promise to the host that nothing keeps.
+ */
+export interface ViewWriteCallbacks {
+    /** Called with the instance a save produced, so a host can open it. */
+    onSaved?(instance: ViewInstance): void;
+    /**
+     * Called only when a save-as actually created a view — not when a save
+     * landed in place. The two read alike from `onSaved`, and they end
+     * differently: an in-place save leaves the user on the button they
+     * pressed, while a copy closes its dialog, opens another view and has
+     * nowhere to put focus but `<body>`. This is how a host learns which one
+     * happened, and `WorkbenchShell` answers it by sending focus to the new
+     * view's title.
+     */
+    onCreated?(instance: ViewInstance): void;
+    /**
+     * Called with the instance a recovered rename produced. Renaming is
+     * started from the view manager, and what became of it is reported here
+     * too, so a host keeps one place to learn what landed.
+     */
+    onRenamed?(instance: ViewInstance): void;
+    /** Called when a recovered delete landed: this view is gone. */
+    onDeleted?(): void;
+    /** Called when a recovered write (retry, overwrite, reload) landed. */
+    onRecovered?(action: WriteAction): void;
+}
+export interface WriteOutcomeProps extends ViewWriteCallbacks {
+    commands: SaveCommands;
+    /** The view's title, so a copy out of a conflict can be offered from it. */
+    title: string;
+}
+/**
+ * What became of the last write of the open view, and the way out of it.
+ *
+ * The line itself is `OutcomeActions`, which the manager's rows draw too;
+ * what lives here is the part only an open view has — a conflict it can make
+ * a copy out of, and the landing a recovered write has to be reported as.
+ */
+export declare function WriteOutcome({ commands, title, onSaved, onCreated, onRenamed, onDeleted, onRecovered, }: WriteOutcomeProps): import('react').JSX.Element | null;
+//# sourceMappingURL=WriteOutcome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WriteOutcome.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/WriteOutcome.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAEV,YAAY,EAEb,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAEV,WAAW,EAGZ,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAKzD;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,uEAAuE;IACvE,OAAO,CAAC,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IACvC;;;;;;;;OAQG;IACH,SAAS,CAAC,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IACzC;;;;OAIG;IACH,SAAS,CAAC,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IACzC,gEAAgE;IAChE,SAAS,CAAC,IAAI,IAAI,CAAC;IACnB,uEAAuE;IACvE,WAAW,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CACzC;AAED,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;IAC3D,QAAQ,EAAE,YAAY,CAAC;IACvB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;CACf;AAwBD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,KAAK,EACL,OAAO,EACP,SAAS,EACT,SAAS,EACT,SAAS,EACT,WAAW,GACZ,EAAE,iBAAiB,sCAqKnB"}