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

package/dist/ui/theme/tokens.d.ts.map

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

package/dist/ui/viewNavigation.d.ts

@@ -0,0 +1,39 @@
+/** One system view (or system board) of a resource, as a link. */
+export interface ViewNavigationView {
+    /** Its instance id (`system:<definition>:<view>`). */
+    id: string;
+    /** Its title, said in the words in force here. */
+    title: string;
+    /** Where it lives in the host's address: its resource's `route`. */
+    path: string;
+    /** Whether the address is on it: its path and every parameter it names. */
+    current: boolean;
+}
+/** One resource the host routes to, as a place of its navigation. */
+export interface ViewNavigationItem {
+    /** The definition's id. */
+    id: string;
+    /** A data resource's workbench, or a dashboard's. */
+    kind: 'data' | 'dashboard';
+    /** The definition's title, said in the words in force here. */
+    title: string;
+    /** Its page in the host's address: its `route` with no view named. */
+    path: string;
+    /**
+     * Whether the address is on its page: its path and every parameter that
+     * path names, whatever view the page has open.
+     */
+    current: boolean;
+    /** Its system views, in the order the definition declares them. */
+    views: readonly ViewNavigationView[];
+}
+/**
+ * The places of the host's navigation (host-integration.md 4.3), from the
+ * `ViewHost` above: every registered resource the host bound a `route` to,
+ * in the order they were registered, with its system views; titles said
+ * in the words in force, so a change of language redraws it, and a
+ * resource registered or bound differently changes it. `current` reads
+ * the router's address; with no router, nothing is current.
+ */
+export declare function useViewNavigation(): readonly ViewNavigationItem[];
+//# sourceMappingURL=viewNavigation.d.ts.map

package/dist/ui/viewNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewNavigation.d.ts","sourceRoot":"","sources":["../../src/ui/viewNavigation.ts"],"names":[],"mappings":"AAgCA,kEAAkE;AAClE,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,EAAE,EAAE,MAAM,CAAC;IACX,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IACjC,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,mEAAmE;IACnE,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACtC;AA2BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,SAAS,kBAAkB,EAAE,CA+BjE"}

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

@@ -0,0 +1,57 @@
+import { AnalysisViewConfig, FieldOption } from '../../model/index.js';
+import { ViewRuntime } from '../../runtime/index.js';
+import { WorkbenchController } from '../../react/index.js';
+import { WorkbenchFeatures } from '../kit/features.js';
+import { ViewMessages } from '../kit/messages.js';
+import { RenderParts } from './parts.js';
+/**
+ * What the analysis parts read of the workbench around them: the data
+ * workbench's own controller, or — for an analysis made inside a dashboard
+ * (D22 C) — the few members a dialog holding its own view supplies.
+ */
+export type AnalysisHost = Pick<WorkbenchController, 'filter' | 'state' | 'autoRun' | 'setAutoRun' | 'canDrill' | 'drill' | 'follow'>;
+export interface AnalysisPartsProps {
+    workbench: AnalysisHost;
+    /** The open analysis view, or null while what is open is not one. */
+    runtime: ViewRuntime<AnalysisViewConfig> | null;
+    /** Wording, merged over what is already in force: where a host translates. */
+    messages?: ViewMessages;
+    /**
+     * The language the surface reads in. The surface is inside the shell this
+     * part is handed to, so the counts this part words itself — 「1,204 组」
+     * — take it from here rather than from the provider.
+     */
+    locale?: string;
+    optionsFor?(remote: string): FieldOption[] | undefined;
+    /**
+     * Which of the workbench's own controls are on screen (D18 XI). One name
+     * here is the analysis view's — `visualization`; the rest belong to the
+     * record view and are passed through untouched.
+     */
+    features?: WorkbenchFeatures;
+    /**
+     * Whether a press on a group offers the follow-ups (D20 追问). On in a
+     * workbench, which opens what they ask beside the view; off where there is
+     * no beside — the dashboard's dialog making a new analysis.
+     */
+    followUps?: boolean;
+    /**
+     * What the visualization panel's way back is called. In the workbench it
+     * stands where the view list stood, and its way back says so; where there
+     * is no list — the dashboard's dialog — the host names it.
+     */
+    visualizationBack?: string;
+    children: RenderParts;
+}
+/**
+ * What makes an analysis view an analysis view: the conditions, what to
+ * aggregate, and the result as a table or a chart. Which of the two is
+ * showing is part of the saved config, and both keep their own settings, so
+ * switching back and forth loses nothing.
+ *
+ * It renders nothing of its own — it hands its parts to `children`, which
+ * draws the shell around them, and hands back none while no analysis view
+ * is open (`parts.ts`).
+ */
+export declare function AnalysisParts({ workbench, runtime, messages: wording, locale, optionsFor, features, followUps, visualizationBack, children, }: AnalysisPartsProps): import('react').ReactNode;
+//# sourceMappingURL=AnalysisParts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AnalysisParts.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/AnalysisParts.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAEV,kBAAkB,EAClB,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAK1D,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AA2B9B,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKvD,OAAO,EAAY,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAGxD;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAC7B,mBAAmB,EACjB,QAAQ,GACR,OAAO,GACP,SAAS,GACT,YAAY,GACZ,UAAU,GACV,OAAO,GACP,QAAQ,CACX,CAAC;AAEF,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,YAAY,CAAC;IACxB,qEAAqE;IACrE,OAAO,EAAE,WAAW,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IAChD,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;IACvD;;;;OAIG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,WAAW,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,EAC5B,SAAS,EACT,OAAO,EACP,QAAQ,EAAE,OAAO,EACjB,MAAM,EACN,UAAU,EACV,QAAQ,EACR,SAAgB,EAChB,iBAAiB,EACjB,QAAQ,GACT,EAAE,kBAAkB,6BAkUpB"}

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

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { WorkbenchShellProps } from './WorkbenchShell.js';
+export interface ConditionBlockProps extends Pick<WorkbenchShellProps, 'onRenderFailure'> {
+    /** The view's own editor; the shell draws the block only when there is one. */
+    editor: ReactNode;
+    /** Whether the editor lives in the title bar's fold rather than open. */
+    folded: boolean;
+    /** The band's id. */
+    id: string;
+    /** What resets the editor's boundary: the open view. */
+    resetKeys: readonly unknown[];
+}
+/**
+ * The conditions, on a surface of their own: the fold's band when the editor
+ * folds, a block that stays open when it does not. Either way the editor is
+ * held by its own boundary, so a throwing editor takes the tray and the rest
+ * of the view stays.
+ */
+export declare function ConditionBlock({ editor, folded, id, resetKeys, onRenderFailure, }: ConditionBlockProps): import('react').JSX.Element;
+//# sourceMappingURL=ConditionBlock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionBlock.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/ConditionBlock.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,mBAAoB,SAAQ,IAAI,CAC/C,mBAAmB,EACnB,iBAAiB,CAClB;IACC,+EAA+E;IAC/E,MAAM,EAAE,SAAS,CAAC;IAClB,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAC;IAChB,qBAAqB;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,wDAAwD;IACxD,SAAS,EAAE,SAAS,OAAO,EAAE,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,MAAM,EACN,EAAE,EACF,SAAS,EACT,eAAe,GAChB,EAAE,mBAAmB,+BAyBrB"}

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

@@ -0,0 +1,21 @@
+import { ViewConfig } from '../../model/index.js';
+import { ConflictChoice } from '../../runtime/index.js';
+/**
+ * The same choice, put once more with both configs on the table.
+ *
+ * Either answer loses something a user cannot see from the button that
+ * offered it, so the two ways of looking are summarised side by side first.
+ *
+ * An `AlertDialog`, not a `Dialog`: whichever config is kept, the other one
+ * goes. Base UI holds it open under an outside click and keeps focus on the
+ * two answers, so neither side is discarded by a stray click.
+ */
+export declare function ConflictConfirm({ choice, local, remote, onOpenChange, onConfirm, }: {
+    /** The choice awaiting confirmation, or null while none is. */
+    choice: ConflictChoice | null;
+    local: ViewConfig | null;
+    remote: ViewConfig | null;
+    onOpenChange(open: boolean): void;
+    onConfirm(choice: ConflictChoice): void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=ConflictConfirm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConflictConfirm.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/ConflictConfirm.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAgB7D;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,KAAK,EACL,MAAM,EACN,YAAY,EACZ,SAAS,GACV,EAAE;IACD,+DAA+D;IAC/D,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC1B,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;CACzC,+BA8CA"}

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

@@ -0,0 +1,73 @@
+import { ReactNode } from 'react';
+export interface EditorFoldProps {
+    open: boolean;
+    /**
+     * Base UI hands a reason along with the new state; this package has one
+     * question — is the editor open — and the workbench answers it the same
+     * way whoever asked.
+     */
+    onOpenChange(open: boolean): void;
+    children: ReactNode;
+}
+/**
+ * The one fold the handle and the band are two halves of.
+ *
+ * The handle sits in the title bar and the band below the status line, with
+ * other blocks between them, so they cannot be nested one in the other —
+ * which is why the pair used to be wired by hand: the open state held above
+ * both, `aria-expanded` and `aria-controls` written out at the trigger, the
+ * panel unmounted with an early `return null`. That is a disclosure, and
+ * `Collapsible` is the disclosure this project already has: one root around
+ * both ends gives the trigger its ARIA pair, drops `aria-controls` while the
+ * panel is away, and unmounts the panel itself.
+ *
+ * The root draws nothing. `contents` keeps it out of the layout entirely, so
+ * the blocks it spans stay direct flex children of the column they were in
+ * and the spacing ruler is untouched.
+ */
+export declare function EditorFold({ open, onOpenChange, children }: EditorFoldProps): import('react').JSX.Element;
+export interface EditorBandProps {
+    /** The id the header's toggle points `aria-controls` at. */
+    id: string;
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * The fold the editor of a view lives in.
+ *
+ * The result is the point of a view, so the editor gives it the room: a saved
+ * view opens folded, a new one open, and the state is the opening's alone —
+ * nothing about how a view is looked at is worth persisting.
+ *
+ * The band draws the editor and nothing else. What opens and closes it sits
+ * in the title bar ({@link EditorBandToggle}), with the other controls for
+ * *how this view is being looked at*, rather than on a row of its own above
+ * the editor: a fold whose handle takes a line is a fold that saved nothing.
+ * Both ends live under one {@link EditorFold}.
+ *
+ * It is a shell and nothing else. It holds no idea of conditions, panels or
+ * aggregations, which is what lets the three workbenches share it while their
+ * editors stay their own.
+ */
+export declare function EditorBand({ id, children, className }: EditorBandProps): import('react').JSX.Element;
+export interface EditorBandToggleProps {
+    label: string;
+    /** The ways of editing this editor offers, under a chevron beside it. */
+    modes?: ReactNode;
+    /** How many nodes say something other than what ran. */
+    pending: number;
+}
+/**
+ * The handle of the editor's fold, in the title bar.
+ *
+ * It carries the one credential the folded editor cannot carry for itself:
+ * the dot and the count for "edited, not applied". Everything else about it
+ * is a button — which is why the mode menu hangs off it as a second button
+ * in one group rather than as an item inside a menu of its own.
+ *
+ * It is the {@link EditorFold}'s trigger, so `aria-expanded`, the
+ * `aria-controls` that points at the band only while the band is there, and
+ * the click that flips the state all come from the primitive.
+ */
+export declare function EditorBandToggle({ label, modes, pending, }: EditorBandToggleProps): import('react').JSX.Element;
+//# sourceMappingURL=EditorBand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EditorBand.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/EditorBand.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAoBvC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,eAAe,+BAU3E;AAED,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,eAAe,+BAoBtE;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,KAAK,EACL,OAAO,GACR,EAAE,qBAAqB,+BA0DvB"}

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

@@ -0,0 +1,27 @@
+import { LeaveGuard } from '../../react/index.js';
+import { ViewMessages } from '../kit/messages.js';
+export interface LeaveDialogProps {
+    /** The headless guard from `useWorkbench`; this only draws its question. */
+    leave: LeaveGuard;
+    /**
+     * The wording in force around the workbench. The dialog is rendered by the
+     * shell *outside* the `ViewSurface` that carries the provider, so without
+     * this a host's `messages` override reaches every component inside the
+     * surface and not the one dialog that interrupts them.
+     */
+    messages?: ViewMessages;
+}
+/**
+ * The confirmation that stands between an open view and the next one.
+ *
+ * Nothing is decided here: `useLeaveGuard` already knows whether anything
+ * would be lost, and this renders the two answers when it asks. A view with
+ * nothing to lose never reaches this component at all — a guard that
+ * interrupts every switch is one people learn to dismiss without reading.
+ *
+ * An `AlertDialog`, not a `Dialog`: the edits this asks about are lost for
+ * good, so Base UI keeps it open under an outside click and holds focus on
+ * the two answers — staying is a decision, not the absence of one.
+ */
+export declare function LeaveDialog({ leave, messages: wording }: LeaveDialogProps): import('react').JSX.Element;
+//# sourceMappingURL=LeaveGuard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LeaveGuard.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/LeaveGuard.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAcvD,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,KAAK,EAAE,UAAU,CAAC;IAClB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,gBAAgB,+BA4BzE"}

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

@@ -0,0 +1,40 @@
+import { MouseEventHandler, ReactElement } from 'react';
+import { ViewKind } from '../../model/index.js';
+/**
+ * The one command behind every "new view" control: which kinds a view may
+ * be made of here, and the making. `creatable` is the whole of whether the
+ * control exists (D4): none, and the control is not drawn.
+ */
+export interface NewViewCommand {
+    creatable: readonly ViewKind[];
+    create(kind: ViewKind): void;
+}
+/**
+ * A control that makes a view, in whichever form its place needs.
+ *
+ * One creatable kind is the trigger itself: pressing it makes that kind, and
+ * the control reads "New view" as it always did. Several are a menu of the
+ * kinds (D20 Ⅱ): the kind decides which kernel the view runs on, so it is
+ * asked before the view opens rather than switched inside it — and the
+ * trigger then opens the menu. The trigger is the caller's, because the
+ * sidebar wants an icon button and the empty work area a labelled one.
+ */
+export declare function NewViewControl({ command, trigger, }: {
+    command: NewViewCommand;
+    /**
+     * The button as the caller draws it. With one kind it is handed the press
+     * that makes it; with several it is handed nothing and becomes the menu's
+     * trigger, which presses it open.
+     */
+    trigger(props: {
+        onClick?: MouseEventHandler;
+    }): ReactElement;
+}): import('react').JSX.Element;
+/**
+ * The same command inside a menu that is already open — the switcher's: one
+ * kind is one item, several are a submenu of the kinds.
+ */
+export declare function NewViewItem({ command }: {
+    command: NewViewCommand;
+}): import('react').JSX.Element;
+//# sourceMappingURL=NewView.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NewView.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/NewView.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAE7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAYrD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC/B,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,OAAO,GACR,EAAE;IACD,OAAO,EAAE,cAAc,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE;QAAE,OAAO,CAAC,EAAE,iBAAiB,CAAA;KAAE,GAAG,YAAY,CAAC;CAC/D,+BAYA;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,cAAc,CAAA;CAAE,+BAsBnE"}

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

@@ -0,0 +1,22 @@
+import { NewViewCommand } from './NewView.js';
+/**
+ * The work area when the definition has no view of this kind to open.
+ *
+ * It used to be nothing at all — a title bar with no title, a body with no
+ * body — which read as a page that had failed to load rather than as a page
+ * with nothing in it yet. **This is the one place the state is stated in
+ * full** (user, 2026-09-22): the sentence, why or what next, and the button.
+ * The sidebar used to draw the same three things forty pixels under its own
+ * `+`; it now says one quiet line where the list would be, and the offer is
+ * here, because this is the room the view will fill. Both still press the
+ * same `create` command. Without that command the state is the sentence
+ * alone (D4): a reader who may not create is told there is nothing, not told
+ * to make something.
+ */
+export declare function NoViews({ failed, create, }: {
+    /** The list could not be loaded, which is a different sentence. */
+    failed: boolean;
+    /** Makes a view; absent when none may be made here (D4). */
+    create?: NewViewCommand;
+}): import('react').JSX.Element;
+//# sourceMappingURL=NoViews.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NoViews.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/NoViews.tsx"],"names":[],"mappings":"AAeA,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAYnE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,EACtB,MAAM,EACN,MAAM,GACP,EAAE;IACD,mEAAmE;IACnE,MAAM,EAAE,OAAO,CAAC;IAChB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB,+BAgCA"}

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

@@ -0,0 +1,35 @@
+export interface OpeningSkeletonProps {
+    /**
+     * Whether the block that is coming is the framed one, so the skeleton
+     * wears the frame the result will (D12). A dashboard's is not.
+     */
+    framed?: boolean;
+    /**
+     * Whether to draw the title bar. It is left out on the one screen that
+     * already has a row in that place: with the sidebar folded away, the
+     * shell draws the way back and the view switcher there, and a skeleton
+     * title bar under it would be two title bars.
+     */
+    header?: boolean;
+}
+/**
+ * What stands there while a view is opening.
+ *
+ * It was one `h-8` bar across the page, which said "something is loading"
+ * and nothing else: the page it stood in has a title bar, a framed result
+ * with a toolbar on top and rows under it, and a single bar promised none
+ * of that — so opening a view was a jump from one shape to another
+ * (P-13). This draws the shape that is coming, at the sizes it will come
+ * at, which is the whole job of a skeleton: the reader's eye is already
+ * where the title will be, and the page does not move under it when the
+ * rows land.
+ *
+ * The frame is `ResultBlock`'s own rather than the same four utilities
+ * typed again — the block decides what its first row looks like, and a
+ * skeleton with a second opinion about that is a skeleton of a different
+ * page. Everything drawn is `aria-hidden`: it is the shape of an answer
+ * and not the answer, and the one thing worth saying out loud is said once
+ * by the live region.
+ */
+export declare function OpeningSkeleton({ framed, header, }: OpeningSkeletonProps): import('react').JSX.Element;
+//# sourceMappingURL=OpeningSkeleton.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OpeningSkeleton.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/OpeningSkeleton.tsx"],"names":[],"mappings":"AA0BA,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,EAC9B,MAAa,EACb,MAAa,GACd,EAAE,oBAAoB,+BA+EtB"}

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

@@ -0,0 +1,20 @@
+/**
+ * The line under the title bar of a view opened from another (D20): the way
+ * back, which names where this one came from — once. It used to say the
+ * origin's name twice (「返回 X · 来自 X」) and the conditions the follow-up
+ * added a third time beside the applied bar and the editor (2026-09-23
+ * audit); the conditions are the applied bar's, which is where every view
+ * says what its rows were fetched under, and the view's own name says which
+ * group it is. It is the workbench's fact rather than the view's, so the
+ * shell draws it from `workbench.held` and no kind's parts know it exists.
+ *
+ * A view handed over from a dashboard has the same line (D26 Q33,
+ * 「返回〈仪表盘〉」): the board is where it came from, and going back is
+ * the host's route (`workbench.board`) — `from` says which it is.
+ */
+export declare function OriginBar({ title, from, onBack, }: {
+    title: string;
+    from: 'view' | 'dashboard';
+    onBack(): void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=OriginBar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OriginBar.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/OriginBar.tsx"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,IAAI,EACJ,MAAM,GACP,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,MAAM,IAAI,IAAI,CAAC;CAChB,+BAoBA"}

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

@@ -0,0 +1,135 @@
+import { ReactNode } from 'react';
+import { FieldOption } from '../../model/index.js';
+import { RecordRow } from '../../record/index.js';
+import { RecordViewRuntime } from '../../runtime/index.js';
+import { RecordActions } from '../../runtime/actions.js';
+import { RecordActionSlots, RecordDetailControl, RecordDetailSection, RecordDetailSectionContext, WorkbenchController } from '../../react/index.js';
+import { ExportedFile } from '../record/exportOffer.js';
+import { RecordCell } from '../record/RecordTable.js';
+import { ViewMessages } from '../kit/messages.js';
+import { WorkbenchFeatures } from '../kit/features.js';
+import { RenderFailureHandler } from '../kit/RenderBoundary.js';
+import { RenderParts } from './parts.js';
+/**
+ * What a host may say about the record views a workbench draws: what may be
+ * done to a record, how a cell is read, whether rows can be picked, and what
+ * an empty result says. None of it is about the frame, and none of it means
+ * anything to an analysis view, so it is one object rather than a spread of
+ * props over the workbench.
+ */
+export interface RecordViewProps {
+    /**
+     * The host's declared actions (`actions()`, host-integration.md 5): what
+     * may be *done* to a record, which the workbench places — the row's
+     * button and menu, the selection's bar, the detail — asks about, runs a
+     * few at a time and reports on the line above the rows. What may be done
+     * belongs to the application that mounted the workbench, not to the way
+     * of looking somebody saved.
+     */
+    actions?: RecordActions;
+    /**
+     * The host's own markup, drawn after the declared actions — one over the
+     * view, one over a selection, one per row: the escape hatch for what a
+     * declaration cannot say, a link out, say.
+     */
+    slots?: RecordActionSlots;
+    /**
+     * Renders one cell of the table; the default reads it as the column says.
+     *
+     * It is the smallest thing a host can change and keep everything else —
+     * a business object with one cell nobody else could draw should not cost
+     * the whole workbench. Fall back to `cellValue` for the cells it has
+     * nothing special to say about, and enum labels, the surface's zone and
+     * the field's number format all keep working.
+     */
+    renderCell?(cell: RecordCell): ReactNode;
+    /**
+     * Whether rows can be picked. On by default; a workbench whose host offers
+     * nothing to do with a selection turns it off rather than showing a column
+     * of checkboxes that lead nowhere.
+     */
+    selectable?: boolean;
+    /**
+     * The empty result in the host's own words — "no orders are waiting" says
+     * more than "no rows". The way out of it is the workbench's either way:
+     * conditions in force are cleared, and with none the condition editor
+     * opens.
+     */
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /**
+     * What the empty result's one button does. Left out, the workbench's own
+     * answer: clear the conditions in force, or open the editor when there
+     * are none. A function is the host's answer instead; `null` is no button
+     * — the sentence alone.
+     */
+    emptyAction?: (() => void) | null;
+    /**
+     * Told whenever an export has been handed to the browser — the file's name,
+     * its contents and how many rows of which scope it holds. A host that
+     * audits what leaves the application reads it; nothing here needs it, and
+     * the download happens either way.
+     */
+    onExported?(file: ExportedFile): void;
+    /**
+     * The record detail: which record is open, for a host that keeps it in
+     * its address, and the host's own sections in it. Left out, the detail is
+     * the workbench's own — a row opens it, its close closes it — and holds
+     * the definition's field groups alone.
+     */
+    detail?: RecordDetailOptions;
+}
+/**
+ * What a host says about the record detail (G2): who holds which record is
+ * open (`RecordDetailControl`, as `instanceId` and `onInstanceChange` hold
+ * the open view), and what the host adds to it.
+ */
+export interface RecordDetailOptions extends RecordDetailControl {
+    /**
+     * The host's sections for the record open, asked each time the detail
+     * draws a record — the context says which, and whether it is whole yet.
+     * A render function, as `slots.row` is: what the application shows about
+     * a record is code, not something a saved view holds.
+     */
+    sections?(context: RecordDetailSectionContext): readonly RecordDetailSection[];
+    /**
+     * The record read the host's way, in place of the definition's groups and
+     * of `sections`: a host whose records answer one question (why did this
+     * fail, and will trying again help) lays that answer out itself. The
+     * panel stays the engine's — opening, reading the whole record, saying it
+     * is gone or refused, the row's commands, focus and the way back.
+     */
+    render?(context: RecordDetailSectionContext): ReactNode;
+    /**
+     * The record's name in the header, in place of its key, which then stands
+     * above it. Asked with the row the detail holds; `undefined` keeps the key.
+     */
+    title?(row: RecordRow): string | undefined;
+}
+export type { ExportedFile } from '../record/exportOffer.js';
+export interface RecordPartsProps extends RecordViewProps {
+    workbench: WorkbenchController;
+    /** The open record view, or null while what is open is not one. */
+    runtime: RecordViewRuntime | null;
+    /** Wording, merged over what is already in force: where a host translates. */
+    messages?: ViewMessages;
+    locale?: string;
+    optionsFor?(remote: string): FieldOption[] | undefined;
+    /**
+     * Which of the workbench's own controls are on screen (D18 XI): export,
+     * the layout switch, column settings, sort settings. All on by default;
+     * one turned off is absent, not disabled.
+     */
+    features?: WorkbenchFeatures;
+    /** Told of a render failure in a host's section of the record detail. */
+    onRenderFailure?: RenderFailureHandler;
+    children: RenderParts;
+}
+/**
+ * What makes a record view a record view: the condition band it edits in,
+ * and the toolbar, rows and paging it reads. It renders nothing of its own —
+ * it hands its parts to `children`, which draws the shell around them, and
+ * hands back none while no record view is open (`parts.ts`).
+ */
+export declare function RecordParts({ workbench, runtime: record, messages: wording, locale, optionsFor, features, actions, slots, renderCell, selectable, emptyTitle, emptyDescription, emptyAction: hostEmptyAction, onExported, detail: detailOptions, onRenderFailure, children, }: RecordPartsProps): ReactNode;
+//# sourceMappingURL=RecordParts.d.ts.map

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

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

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

@@ -0,0 +1,70 @@
+import { RefreshController } from '../../react/index.js';
+export interface RefreshControlProps {
+    refresh: RefreshController;
+    /**
+     * `ghost` above a result, where a toolbar must not compete with the rows
+     * under it; `outline` in a title bar, among controls that all wear one.
+     */
+    variant?: 'ghost' | 'outline';
+    /**
+     * Whether something other than this view's own query makes a refresh
+     * pointless right now — a dashboard still resolving its references. The
+     * controller's own `loading` is added to it.
+     */
+    busy?: boolean;
+    /**
+     * One line at the top of the menu, for a surface whose timer is not the
+     * open view's alone: a dashboard holds one timer for every panel, and the
+     * interval saved in a referenced view is ignored inside it.
+     */
+    note?: string;
+    /**
+     * Whether the `▾` offers the intervals (on by default). An embed turns it
+     * off: how often a board renews itself is its author's, and the host's
+     * `autoRefresh` — a reader of someone else's page gets the one press.
+     */
+    choose?: boolean;
+}
+/**
+ * Refreshing the view: one press for now, the `▾` for how often by itself.
+ *
+ * The two halves are one control because they answer one question — how the
+ * numbers on screen get renewed — and two separate buttons would give the
+ * rare choice the weight of the daily one. The primary half is exactly
+ * the one-shot refresh it has always been.
+ *
+ * What the menu offers is cut to what the limits admit: an interval the
+ * kernel would refuse is **absent** rather than disabled (D4), and a view
+ * with no interval to choose gets no `▾` at all rather than a chevron that
+ * opens on the state it is already in.
+ *
+ * Choosing writes `refresh.interval` into the draft and applies it, which is
+ * the edit-then-apply path sorting and column changes take (D3's exception):
+ * the runtime's timer reads `applied`, so an edit that stopped short of
+ * applying would change the config and nothing else. While an interval is in
+ * force the button wears the cadence — it says *this view refreshes itself
+ * every 30s*, a fact about the view rather than a fourth credential
+ * competing with the three of D2, which say whether what is on screen has
+ * been applied, run, or saved.
+ *
+ * The two halves therefore answer to two different ages of the same member,
+ * and deliberately: the menu marks the **picked** interval, because that is
+ * the editor's value and what a save would write, while the cadence says the
+ * one **in force**, because it is a claim about what is happening. They
+ * differ only while a draft the kernel refuses holds `apply` back — the
+ * state the strip above the result is already explaining — and in it the
+ * older number is the true one. Reading the draft in both places would put a
+ * cadence on the button that nothing is running to.
+ *
+ * The UI invents no reason of its own for the timer to stop: the four the
+ * runtime holds it for (`docs/design/runtime.md`) are the whole list.
+ *
+ * What the cadence says while the timer runs is the time **left** of it, and
+ * it ticks: the runtime publishes when the next refresh is due, and the
+ * control counts to that one number rather than keeping a clock of its own.
+ * A cadence that only ever said "30s" answered a question nobody had — how
+ * often, which the menu already says — while the question a person actually
+ * asks of a screen that moves by itself is *when*.
+ */
+export declare function RefreshControl({ refresh, variant, busy, note, choose, }: RefreshControlProps): import('react').JSX.Element;
+//# sourceMappingURL=RefreshControl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RefreshControl.d.ts","sourceRoot":"","sources":["../../../src/ui/workbench/RefreshControl.tsx"],"names":[],"mappings":"AAeA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAwB9B,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,iBAAiB,CAAC;IAC3B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,OAAiB,EACjB,IAAY,EACZ,IAAI,EACJ,MAAa,GACd,EAAE,mBAAmB,+BAmLrB"}