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

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

@@ -0,0 +1,84 @@
+import { DashboardFilters } from '../../model/index.js';
+import { ViewEngine, ViewHandOver } from '../../runtime/index.js';
+import { ViewDestination, ViewLocation, ViewRouteState, ViewRouter } from '../../runtime/routes.js';
+import { RecordDetailControl } from '../../react/index.js';
+/** The search parameter naming the open view (or board). */
+export declare const VIEW_PARAM = "view";
+/** The search parameter naming the record open in the detail. */
+export declare const RECORD_PARAM = "id";
+/** A search parameter of `location`, or `null`. */
+export declare function paramOf(location: ViewLocation, name: string): string | null;
+/** `location`'s path and search with `name` set to `value`, or taken off. */
+export declare function withParam(location: ViewLocation, name: string, value: string | null): string;
+/** What the page was handed, read defensively off the history entry. */
+export declare function routeStateOf(location: ViewLocation): ViewRouteState;
+/**
+ * The router's handling of a way off: a route goes there with what the
+ * page opens with, a path of the host's own goes there, another site opens
+ * apart, and a target the host bound no route for goes nowhere.
+ */
+export declare function routerNavigate(router: () => ViewRouter): (to: ViewDestination) => void;
+/** The router, read at call time: callbacks stay put as it moves. */
+export declare function useLatestRouter(router: ViewRouter | undefined): () => ViewRouter | undefined;
+/**
+ * Which view a workbench opens, and where it says it moved: the props, or
+ * — with neither given, under a router — the address's `?view=`, a new
+ * view a new history entry.
+ *
+ * Only a view of the workbench's own definition: two workbenches on one
+ * page share the one `?view=`, and a view of the other's is no view of
+ * this one's. Such a view is set aside — the workbench keeps the view it
+ * had (or, opening on one, its default) — and is never answered: the
+ * workbench does not write its default over the other's view. A saved
+ * view is known by the definition's list, read once and again for an id
+ * it did not name; until it answers, a workbench opening on one opens it
+ * (`useWorkbench` refuses it before it runs if it is another's, and the
+ * list's answer then turns it to the default), and one already open keeps
+ * what it has.
+ */
+export declare function useAddressedInstance(engine: ViewEngine, definitionId: string, instanceId: string | null | undefined, onInstanceChange: ((id: string | null) => void) | undefined): {
+    instanceId: string | null | undefined;
+    onInstanceChange: ((id: string | null) => void) | undefined;
+};
+/**
+ * The view a workbench is handed: the prop, or — left out, under a router
+ * — the one the history entry holds. A browser hands the entry's state
+ * back as a copy each time the entry is written (a record opened replaces
+ * it), and a workbench opens each new object it is handed; so the same
+ * view, as data, is the same object here, and opens once.
+ */
+export declare function useAddressedHandOver(handOver: ViewHandOver | null | undefined): ViewHandOver | null | undefined;
+/** What a board opens on and says as it changes; see `useAddressedBoard`. */
+export interface BoardAddress {
+    initialFilters?: DashboardFilters | null;
+    onFiltersChange?(filters: DashboardFilters): void;
+    initialTab?: string | null;
+    onTabChange?(tab: string | null): void;
+}
+/**
+ * Which board a surface's filters and tab are kept under in the history
+ * entry (`ViewRouteState.boards`): the board it names, or — a workbench
+ * left on its default — its definition's default.
+ */
+export declare function boardKey(instanceId: string | null | undefined, definitionId?: string): string;
+/**
+ * A board's filters and tab: the props, each pair on its own, or — left
+ * out, under a router — the history entry's, written back to it (replacing
+ * it) as the reader changes them, so a reload and the way back from a
+ * workbench find the board as it was left.
+ *
+ * Each board keeps its own under `key` (`boardKey`), in the entry's
+ * `boards`: several boards on one page — two embeds, an embed beside a
+ * workbench — each find their own again, where one shared pair went to
+ * whichever wrote last. What the entry holds at its top (`filters`, `tab`:
+ * what a way off hands the page it opens) is read by a board that has
+ * written nothing of its own yet, and never written over.
+ */
+export declare function useAddressedBoard<P extends BoardAddress>(props: P, key: string): P;
+/**
+ * The record open in the address (`?id=`), for `ViewHost` to hand every
+ * bound resource's detail: opening one record after another is reading,
+ * not moving, so it replaces the entry. `undefined` without a router.
+ */
+export declare function useAddressedDetail(router: ViewRouter | undefined): RecordDetailControl | undefined;
+//# sourceMappingURL=address.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/address.ts"],"names":[],"mappings":"AA+BA,OAAO,EAGL,KAAK,gBAAgB,EAEtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,cAAc,EACd,UAAU,EACX,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGhE,4DAA4D;AAC5D,eAAO,MAAM,UAAU,SAAS,CAAC;AAEjC,iEAAiE;AACjE,eAAO,MAAM,YAAY,OAAO,CAAC;AAEjC,mDAAmD;AACnD,wBAAgB,OAAO,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE3E;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CACvB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,MAAM,CAMR;AAED,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,cAAc,CAGnE;AAOD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,UAAU,GACvB,CAAC,EAAE,EAAE,eAAe,KAAK,IAAI,CAQ/B;AAED,qEAAqE;AACrE,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,GAAG,SAAS,GAC7B,MAAM,UAAU,GAAG,SAAS,CAM9B;AA0CD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACrC,gBAAgB,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,GAC1D;IACD,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,gBAAgB,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC7D,CAyFA;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,GACxC,YAAY,GAAG,IAAI,GAAG,SAAS,CASjC;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,cAAc,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACzC,eAAe,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAClD,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACxC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACrC,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAER;AAkBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,YAAY,EACtD,KAAK,EAAE,CAAC,EACR,GAAG,EAAE,MAAM,GACV,CAAC,CAmDH;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,UAAU,GAAG,SAAS,GAC7B,mBAAmB,GAAG,SAAS,CAoBjC"}

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

@@ -0,0 +1,45 @@
+import { RoutedTarget } from '../../runtime/routes.js';
+import { RecordActions } from '../../runtime/actions.js';
+import { RecordActionSlots } from '../../react/index.js';
+import { RecordDetailOptions } from './RecordParts.js';
+export interface ViewBindingOptions {
+    /**
+     * Where a view or a board of this definition lives in the host's
+     * address: the path of the page that opens `instanceId` — `null` for a
+     * view nobody saved (a follow-up on a group, a board's own analysis),
+     * which opens on the page's default and is handed over whole. The engine
+     * hands the host's router (or `navigate`) the path with what the page
+     * opens with (`ViewRoute.state`); a definition with no route is handed
+     * over raw. `target` is absent where the engine asks for a link rather
+     * than a way off: the resource's place in `useViewNavigation`.
+     */
+    route?(instanceId: string | null, target?: RoutedTarget): string;
+    /**
+     * How one of its records is read (D60): the detail's own reading of the
+     * record, its title, its sections, who holds which record is open — what
+     * `DataWorkbench` takes as `record.detail`, and what an `EmbeddedView`'s
+     * `detail` opens with. A surface's own prop wins.
+     */
+    reading?: RecordDetailOptions;
+    /**
+     * The commands its records take, declared (`actions()`,
+     * host-integration.md 5): the engine places them wherever its records are
+     * drawn — the workbench's rows, selection and detail, and every record
+     * panel of a board over it (D39) — asks first, runs them a few at a time
+     * and says how it went. A surface's own prop wins.
+     */
+    actions?: RecordActions;
+    /**
+     * The host's own markup beside them — a row's, a selection's, the
+     * view's — the escape hatch for what a declaration cannot say, drawn
+     * after the declared actions. A surface's own prop wins.
+     */
+    slots?: RecordActionSlots;
+}
+/** One definition's binding, as `ViewHost` takes it. */
+export interface ViewBinding extends ViewBindingOptions {
+    readonly definitionId: string;
+}
+/** Binds a definition's behaviour in the host (host-integration.md 4). */
+export declare function bind(definitionId: string, options?: ViewBindingOptions): ViewBinding;
+//# sourceMappingURL=bindings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/bindings.ts"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;OASG;IACH,KAAK,CAAC,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;IACjE;;;;;OAKG;IACH,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE,iBAAiB,CAAC;CAC3B;AAED,wDAAwD;AACxD,MAAM,WAAW,WAAY,SAAQ,kBAAkB;IACrD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,0EAA0E;AAC1E,wBAAgB,IAAI,CAClB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,kBAAuB,GAC/B,WAAW,CAEb"}

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

@@ -0,0 +1,28 @@
+import { Issue } from '../../model/index.js';
+/**
+ * Where a record view's config is fixed, by the part of it an error is
+ * about:
+ *
+ * - `page-size` — a stored page size the limits refuse: one press sets the
+ *   admitted size nearest it (the pagination that would offer sizes is not
+ *   drawn while the view will not run);
+ * - `layout` — a layout the definition no longer offers: one press switches
+ *   to one it does;
+ * - `sort` — the sort settings;
+ * - `card` — the card settings;
+ * - `columns` — the column settings, which hold the columns and their
+ *   summaries.
+ */
+export type ConfigRemedy = 'page-size' | 'layout' | 'sort' | 'card' | 'columns';
+/**
+ * The remedy for the first error a remedy exists for, or `null`.
+ *
+ * The error strip offers one way out, and it used to be the column settings
+ * whatever the error was: a page size over the limit sent the reader to a
+ * panel that holds no page size, and the view could not be fixed from the
+ * screen at all (second review R1-P1-3). One button for the first fixable
+ * error is the strip's shape — it lists the rest — and once that one is
+ * fixed, the next error brings its own.
+ */
+export declare function configRemedy(issues: readonly Issue[]): ConfigRemedy | null;
+//# sourceMappingURL=configRemedy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"configRemedy.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/configRemedy.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAWhF;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,YAAY,GAAG,IAAI,CAQ1E"}

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

@@ -0,0 +1,23 @@
+import { ViewConfig } from '../../model/index.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/**
+ * One config as a single line.
+ *
+ * A conflict asks the user to choose between two configs, and neither is
+ * something they can read: a config is a tree of ids. This says the handful
+ * of facts that actually differ between two ways of looking at the same
+ * data, so the choice is made on what changes rather than on trust.
+ *
+ * It is a pure function of the config and the wording — no clock, no
+ * definition, no field labels — because a conflicting remote config may name
+ * fields this release has never heard of.
+ *
+ * And it reads every part of it defensively, for the same reason. One side of
+ * the conflict is whatever the store handed back: a config written by another
+ * release, or one that lost its shape. A `.length` on something that is not
+ * an array would throw out of a render and take the dialog with it — the one
+ * dialog whose whole job is to recover — so a shape the kind does not promise
+ * is a sentence saying so, and the choice can still be made on the other side.
+ */
+export declare function describeConfig(config: ViewConfig, messages: MessageFormatters): string;
+//# sourceMappingURL=describeConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"describeConfig.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/describeConfig.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,CA6CR"}

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

@@ -0,0 +1,43 @@
+import { Issue } from '../../model/index.js';
+import { MessageFormatters } from '../kit/MessagesProvider.js';
+/**
+ * How many panels these errors are about, when every one of them is a
+ * panel's own — the open board's (`['panels', m, …]`), or the same panel
+ * as the definition that declares the board at `view` says it
+ * (`['views', view, 'config', 'panels', m, …]`) — and `0` when any is the
+ * board's own: its filters, its grid, how many panels it has. A finding
+ * about another view the definition declares (`['views', n, …]`, `n` not
+ * `view`) is about neither: a sibling board's panel 3 is no panel of this
+ * one, so it is not counted, nor taken for this board's panel 3, and it
+ * does not stop this board running.
+ *
+ * A panel's error puts out that panel alone and the rest draw (D22 B,
+ * todo C), so a board whose only trouble is its panels still runs, and
+ * the line over it says so of the panels rather than of the board.
+ */
+export declare function panelsToFix(issues: readonly Issue[], view?: number | null): number;
+/**
+ * Whether a definition's finding is about a panel of the board it declares
+ * at `view` — which that board, open, reports itself, at `['panels', m, …]`
+ * and by the names a reader sees. The status line leaves such an error out
+ * of the definition's, so each is said once, named.
+ */
+export declare function saidByBoard(found: Issue, view: number | null): boolean;
+/**
+ * Whether a definition's finding is about another view it declares than
+ * the board open at `view` (`['views', n, …]`, `n` not `view`; any of them
+ * when the board open is not one it declares). On a board it is left to
+ * the board it is about, which says it when it is open — its panels by
+ * their names, its own the definition's way — so it never heads, nor
+ * joins, the line over a board it says nothing of.
+ */
+export declare function ofAnotherBoard(found: Issue, view: number | null): boolean;
+/**
+ * What a board's error line is headed with, over two findings or more
+ * (`ErrorStrip`): 「有 2 个面板要先修正才能显示」 when only panels are
+ * broken — the rest of the board draws — and 「这个仪表盘要先修正才能运行」
+ * when the board itself is. `view` is where the definition declares the
+ * board open, if it does (`panelsToFix`).
+ */
+export declare function boardErrorTitle(issues: readonly Issue[], messages: MessageFormatters, view?: number | null): string;
+//# sourceMappingURL=panelsToFix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panelsToFix.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/panelsToFix.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,IAAI,GAAE,MAAM,GAAG,IAAW,GACzB,MAAM,CAaR;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAEtE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,GAAE,MAAM,GAAG,IAAW,GACzB,MAAM,CAKR"}

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

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+import { WorkbenchShellProps } from './WorkbenchShell.js';
+/**
+ * What one kind of view puts into the shell's slots: its editor and how it
+ * folds, its toolbar, its result and the way out of an error, and the host's
+ * actions over it.
+ *
+ * It is a `Pick` of the shell's own props rather than a contract of its own
+ * (D18-1): the shell has one slot table, and a kind fills the part of it that
+ * is about the view rather than about the frame — the sidebar, the title, the
+ * theme and the wording stay the workbench's to pass. Everything the shell
+ * can draw by itself from the controller — the refresh, the query strip, the
+ * warnings — is not in it: a part that repeated those would be the drift
+ * this type exists to end.
+ */
+export type WorkbenchParts = Pick<WorkbenchShellProps, 'actions' | 'search' | 'editor' | 'editorLabel' | 'editorModes' | 'editorOpen' | 'onEditorOpenChange' | 'editorPending' | 'toolbar' | 'result' | 'errorAction' | 'besideResult' | 'nameIssue' | 'resultSlots' | 'resultWithoutQuery' | 'panel' | 'onPanelClose'>;
+/**
+ * A kind's parts are made by a component, not a function: each kind's
+ * controller is a hook (`useRecordTable`, `useAnalysisEditor`), and a hook
+ * cannot be called on a branch. So the parts are handed back through a
+ * render prop, and the workbench draws the shell around them.
+ *
+ * The component stays mounted whether or not a view of its kind is open —
+ * it is handed `null` then, and hands back no parts. The shell is drawn
+ * inside the render prop, so a part that came and went with the view would
+ * take the shell with it: every switch releases one runtime before the next
+ * opens, and a shell remounted in between forgets the screen's posture —
+ * the list folded away, the view filling the screen.
+ */
+export type RenderParts = (parts: WorkbenchParts) => ReactNode;
+/** What a part hands back while no view of its kind is open. */
+export declare const NO_PARTS: WorkbenchParts;
+//# sourceMappingURL=parts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parts.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/parts.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAC/B,mBAAmB,EACjB,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,aAAa,GACb,aAAa,GACb,YAAY,GACZ,oBAAoB,GACpB,eAAe,GACf,SAAS,GACT,QAAQ,GACR,aAAa,GACb,cAAc,GACd,WAAW,GACX,aAAa,GACb,oBAAoB,GACpB,OAAO,GACP,cAAc,CACjB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,SAAS,CAAC;AAE/D,gEAAgE;AAChE,eAAO,MAAM,QAAQ,EAAE,cAAmB,CAAC"}

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

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+/**
+ * The editor's fold, which belongs to one opening of one view.
+ *
+ * The state is tagged with the runtime it was made for rather than reset by
+ * an effect: switching views re-reads the default in the same render that
+ * shows the new view, so the band is never briefly the previous view's.
+ */
+export declare function useEditorFold({ controlled, fallback, runtimeId, onChange, }: {
+    controlled: boolean | undefined;
+    fallback: boolean;
+    runtimeId: string | null;
+    onChange?(open: boolean): void;
+}): {
+    open: boolean;
+    set(open: boolean): void;
+};
+/**
+ * Whether a slot was given something that will draw.
+ *
+ * A workbench fills a slot with `condition && <Thing/>`, so an unfilled one
+ * arrives as `false` rather than as nothing at all — and a block that
+ * counted it as content would be the empty card the layout rule forbids.
+ */
+export declare function filled(slot: ReactNode): boolean;
+//# sourceMappingURL=useEditorFold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorFold.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/useEditorFold.ts"],"names":[],"mappings":"AAaA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEjD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,EAC5B,UAAU,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,GACT,EAAE;IACD,UAAU,EAAE,OAAO,GAAG,SAAS,CAAC;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;CAChC,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAA;CAAE,CAY9C;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAE/C"}

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

@@ -0,0 +1,57 @@
+import { RefObject } from 'react';
+/**
+ * The width below which the list stops being *beside* the view.
+ *
+ * It is Tailwind's `md`, written as the number the stylesheet uses, because
+ * this is the same threshold the surface changes direction at: above it the
+ * shell is a row and the column stands next to the work area; below it the
+ * shell is a column and the list is a block on top of the result.
+ */
+export declare const NARROW = 768;
+/**
+ * The sidebar's fold as the *page* has it, and the measurement that answers
+ * for it until the user answers for themselves.
+ *
+ * **The width is followed, not sampled once.** A window dragged from 1280 to
+ * 608 is the same phone-shaped column as one that opened at 608, and a list
+ * that stayed beside a view which is no longer beside anything is 224px of
+ * navigation stacked on top of the first row. So the surface is watched with
+ * a `ResizeObserver` and the rule runs again on every change, in both
+ * directions: narrowing folds the list away, widening brings it back.
+ *
+ * **It is the surface that is observed, not the window.** A 360px panel on a
+ * 1440px page is the same phone-shaped column, and a host that resizes that
+ * panel without the window moving at all would otherwise never be heard —
+ * which is the lesson `ViewHeader`'s container queries already learned.
+ *
+ * **A press ends the measurement.** Once the user has folded the list away or
+ * called it back, that is the answer for as long as this surface is mounted:
+ * a measurement that flipped it back would be undoing, under their hands,
+ * the one thing they explicitly asked for — and every later drag of the
+ * window would undo it again. Before they press, the measurement decides both
+ * ways; after, it decides nothing. Nothing is remembered past unmount, since
+ * this is view state and nothing else: never saved, never asked about by the
+ * leave guard.
+ *
+ * A width of 0 is jsdom, a detached tree, or a host that has not laid this
+ * out yet, all saying nothing at all — and nothing is not a reason to fold.
+ * A host that passed `forced` is obeyed at every width and never measured:
+ * it knows something about its page that a measurement does not.
+ */
+export declare function useSidebarFold(surface: RefObject<HTMLElement | null>, forced: boolean | undefined, onChange?: (open: boolean) => void): {
+    open: boolean;
+    set(open: boolean): void;
+};
+/**
+ * Whether the surface is narrower than `NARROW` — the width below which the
+ * shell stacks its column over the work area — followed as it changes, and
+ * never overruled by a press: it is a fact about the room, not a choice.
+ *
+ * What stands in the column (the visualization panel) is a block on top of
+ * the result on such a screen: on a phone the chart types took the whole
+ * first screen and pushed the chart they were for below it (2026-09-23
+ * audit). The shell draws it in a drawer instead (`SidebarColumn`). A width
+ * of 0 says nothing, as in `useSidebarFold`, and reads as wide.
+ */
+export declare function useNarrowSurface(surface: RefObject<HTMLElement | null>): boolean;
+//# sourceMappingURL=useSidebarFold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSidebarFold.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/useSidebarFold.ts"],"names":[],"mappings":"AAaA,OAAO,EAAqC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE1E;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,MAAM,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACtC,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GACjC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAA;CAAE,CA+C7C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,GACrC,OAAO,CAmBT"}

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

@@ -0,0 +1,44 @@
+import { RefObject } from 'react';
+import { ViewExpansion } from '../kit/ViewExpansion.js';
+export interface WorkbenchFoldsOptions {
+    /**
+     * Whether the workbench offers to fill the screen at all. A page that is
+     * already a full-screen view of one thing has nothing to gain from it.
+     */
+    expandable: boolean;
+    /** Whether a view opened and is the page's to draw. */
+    open: boolean;
+    /** Whether the next view is on its way. */
+    opening: boolean;
+    /** Controlled page fold; the measurement answers for it when left out. */
+    defaultSidebarOpen?: boolean;
+    /** Told whenever either fold opens or closes, for a host that mirrors it. */
+    onSidebarOpenChange?(open: boolean): void;
+}
+export interface WorkbenchFolds {
+    /** The shell's own root, which the fill expands where it already is. */
+    surfaceRef: RefObject<HTMLDivElement | null>;
+    /** The title bar's fill toggle, which the expansion returns focus to. */
+    expandViewRef: RefObject<HTMLButtonElement | null>;
+    /** The sidebar's own fold button, focused when expanding took it away. */
+    collapseRef: RefObject<HTMLButtonElement | null>;
+    /** The collapsed row's unfold button, focused when collapsing took it away. */
+    expandRef: RefObject<HTMLButtonElement | null>;
+    /** The fold as it is on screen right now. */
+    sidebarOpen: boolean;
+    /** A press of either fold button; focus follows it. */
+    toggleSidebar(next: boolean): void;
+    /** Filling the screen, as the title bar's toggle governs it. */
+    fill: ViewExpansion;
+}
+/**
+ * The two folds a workbench shell holds: whether the view list is beside the
+ * view, and whether the view fills the screen.
+ *
+ * They are one concern rather than two because the second decides the first.
+ * Both belong to this screen at this moment — nothing about them is worth
+ * saving, and the leave guard has nothing to ask about them — which is why
+ * the shell holds them rather than handing every workbench the same state.
+ */
+export declare function useWorkbenchFolds({ expandable, open, opening, defaultSidebarOpen, onSidebarOpenChange, }: WorkbenchFoldsOptions): WorkbenchFolds;
+//# sourceMappingURL=useWorkbenchFolds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkbenchFolds.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/useWorkbenchFolds.ts"],"names":[],"mappings":"AAaA,OAAO,EAAqC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAI7D,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,IAAI,EAAE,OAAO,CAAC;IACd,2CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,6EAA6E;IAC7E,mBAAmB,CAAC,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,UAAU,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC7C,yEAAyE;IACzE,aAAa,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACnD,0EAA0E;IAC1E,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACjD,+EAA+E;IAC/E,SAAS,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC/C,6CAA6C;IAC7C,WAAW,EAAE,OAAO,CAAC;IACrB,uDAAuD;IACvD,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IACnC,gEAAgE;IAChE,IAAI,EAAE,aAAa,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,UAAU,EACV,IAAI,EACJ,OAAO,EACP,kBAAkB,EAClB,mBAAmB,GACpB,EAAE,qBAAqB,GAAG,cAAc,CAmHxC"}