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

package/dist/ui/kit/ExportDialog.d.ts

@@ -0,0 +1,111 @@
+import { ReactNode } from 'react';
+import { FilterSummaryItem } from '../../filter/index.js';
+import { RecordExportController } from '../../react/index.js';
+import { DetachedDialog } from './toolbar.js';
+import { FinalFocus } from './focus.js';
+/**
+ * What a surface hands over to offer an export of its result — the run
+ * itself, plus the two things only the surface can say about the file.
+ */
+export interface ExportOffer {
+    /** The two scopes, the one run and what it produced; see `useRecordExport`. */
+    control: RecordExportController;
+    /**
+     * The conditions the rows came back under, as the applied band names
+     * them. A host's own scope is in force too and belongs here: the export
+     * runs under the applied config with that scope merged in, exactly like
+     * the rows on screen.
+     */
+    conditions: readonly FilterSummaryItem[];
+    /**
+     * What the file will be called: `<view name>-<yyyy-MM-dd>.csv`.
+     *
+     * Asked **once, as the window opens**, rather than read off every render.
+     * The name carries a day in it, so a window left open across midnight
+     * would otherwise promise one name and hand over another — one journey,
+     * one shell, one promise (D14).
+     */
+    nameFile(): string;
+    /**
+     * What the file holds, in the surface's own unit, where its rows are not
+     * records: an analysis's groups and its totals row (D25 Q28). `rows` is
+     * the summary's first line and `done` the outcome's. Left out, the window
+     * counts records by the scope picked.
+     */
+    holds?: {
+        rows: string;
+        done: string;
+    };
+}
+export interface ExportWindowProps extends ExportOffer {
+    /**
+     * The columns the file will hold, in the order the table draws them —
+     * the very list the serialiser writes into the header row. Only what each
+     * is called is read.
+     */
+    columns: readonly {
+        label: string;
+    }[];
+    /** The ceiling one export carries — `limits.exportMax`. */
+    max: number;
+}
+export interface ExportDialogProps extends ExportWindowProps {
+    /**
+     * Whether the window is open. Whatever offers the export opens it — the
+     * toolbar's own button (`ExportButton`), or 「导出数据…」 in a dashboard
+     * panel's 「⋯」 — and the window closes itself.
+     */
+    open: boolean;
+    /**
+     * Told as the window opens from its own trigger and as it closes itself —
+     * Close, Cancel, Escape, the backdrop. While the pages are coming in,
+     * closing is stopping: the run is cancelled first.
+     */
+    onOpenChange(open: boolean): void;
+    /**
+     * Where the keyboard goes as it closes (`FinalFocus`): the control that
+     * opened it — a menu's trigger, since the item that was pressed went with
+     * the menu. Base UI's own choice (the trigger) when left out.
+     */
+    finalFocus?: FinalFocus;
+    /** The control that opens it, where the window has one of its own. */
+    trigger?: ReactNode;
+    /**
+     * What joins it to a trigger drawn elsewhere — a toolbar's, outside
+     * whose subtree the window is drawn (`DetachedDialog`).
+     */
+    handle?: DetachedDialog['handle'];
+}
+/**
+ * The export's own button and its window: one bordered icon button at the
+ * end of the toolbar's right-hand block (D12 Ⅳ), because exporting is a
+ * display facility like the columns and the sort — it changes nothing about
+ * the view and nothing about the records. It opens `ExportDialog`.
+ */
+export declare function ExportButton({ detached, ...props }: ExportWindowProps & {
+    /**
+     * Draws one half of it, joined to the other by a handle: the button
+     * inside a toolbar, the window beside it (`DetachedDialog`). Left out,
+     * both halves are drawn here together.
+     */
+    detached?: DetachedDialog;
+}): import('react').JSX.Element;
+/**
+ * Taking the result away: what is picked, or everything the applied
+ * conditions match — chosen, waited for and read in **one window** (D14).
+ *
+ * It used to be a menu, and a menu is a surface for choosing rather than a
+ * surface for waiting — holding it open with a progress line in it fought
+ * its own conventions (Escape and a click outside had to be refused), it was
+ * too narrow to say what the file would hold, and the over-limit question
+ * already had a dialog of its own: two shells for one journey. A window is
+ * allowed to wait, wide enough to say what is being agreed to, and is the
+ * one place the cancel lives — so Escape and the backdrop **stop the run**
+ * here rather than being ignored.
+ *
+ * It is controlled, so whatever offers the export opens it: the toolbar's
+ * button (`ExportButton`), or a dashboard panel's menu, whose item goes
+ * with the menu and so cannot be the window's trigger.
+ */
+export declare function ExportDialog({ open, onOpenChange, finalFocus, trigger, handle, ...props }: ExportDialogProps): import('react').JSX.Element;
+//# sourceMappingURL=ExportDialog.d.ts.map

package/dist/ui/kit/ExportDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExportDialog.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/ExportDialog.tsx"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,SAAS,EAEf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EACV,sBAAsB,EAEvB,MAAM,sBAAsB,CAAC;AAY9B,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAW7C;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,OAAO,EAAE,sBAAsB,CAAC;IAChC;;;;;OAKG;IACH,UAAU,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACzC;;;;;;;OAOG;IACH,QAAQ,IAAI,MAAM,CAAC;IACnB;;;;;OAKG;IACH,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACxC;AAED,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD;;;;OAIG;IACH,OAAO,EAAE,SAAS;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtC,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D;;;;OAIG;IACH,IAAI,EAAE,OAAO,CAAC;IACd;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,sEAAsE;IACtE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB;;;OAGG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;CACnC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,iBAAiB,GAAG;IACrB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B,+BAmCA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,YAAY,EACZ,UAAU,EACV,OAAO,EACP,MAAM,EACN,GAAG,KAAK,EACT,EAAE,iBAAiB,+BAkDnB"}

package/dist/ui/kit/ExportSteps.d.ts

@@ -0,0 +1,38 @@
+import { RefObject } from 'react';
+import { RecordExportController, RecordExportScope } from '../../react/index.js';
+import { ExportOffer, ExportWindowProps } from './ExportDialog.js';
+import { MessageFormatters } from './MessagesProvider.js';
+/** Which of the four things the one window is saying at this moment. */
+export type ExportPhase = 'choose' | 'running' | 'done' | 'failed';
+/** What the window is saying, read off the controller rather than stored. */
+export declare function phaseOf(control: RecordExportController): ExportPhase;
+/** The window's one-line description, which is a different line per phase. */
+export declare function said(phase: ExportPhase, control: RecordExportController, messages: MessageFormatters, holds?: ExportOffer['holds']): string;
+/** Step one: which rows, and what the file that holds them will look like. */
+export declare function ChooseStep({ control, columns, conditions, fileName, max, holds, scope, onScope, }: ExportWindowProps & {
+    /** The name this opening settled on; see `ExportOffer.nameFile`. */
+    fileName: string;
+    scope: RecordExportScope;
+    onScope(scope: RecordExportScope): void;
+}): import('react').JSX.Element;
+/** Step two: how far it has got. The way to stop it is the footer's button. */
+export declare function RunningStep({ control }: {
+    control: RecordExportController;
+}): import('react').JSX.Element;
+/** Step three: what the file holds, and what it had to leave out. */
+export declare function DoneStep({ control, fileName, max, }: {
+    control: RecordExportController;
+    fileName: string;
+    max: number;
+}): import('react').JSX.Element | null;
+/** The one or two buttons this phase ends in. */
+export declare function ExportActions({ phase, control, scope, fileName, primary, onClose, }: {
+    phase: ExportPhase;
+    control: RecordExportController;
+    scope: RecordExportScope;
+    /** The name this opening settled on; see `ExportOffer.nameFile`. */
+    fileName: string;
+    primary: RefObject<HTMLButtonElement | null>;
+    onClose(): void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=ExportSteps.d.ts.map

package/dist/ui/kit/ExportSteps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExportSteps.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/ExportSteps.tsx"],"names":[],"mappings":"AAaA;;;;GAIG;AAEH,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,KAAK,EACV,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,sBAAsB,CAAC;AAc9B,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAIhF,wEAAwE;AACxE,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEnE,6EAA6E;AAC7E,wBAAgB,OAAO,CAAC,OAAO,EAAE,sBAAsB,GAAG,WAAW,CAOpE;AAED,8EAA8E;AAC9E,wBAAgB,IAAI,CAClB,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,GAC3B,MAAM,CAWR;AAED,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,GAAG,EACH,KAAK,EACL,KAAK,EACL,OAAO,GACR,EAAE,iBAAiB,GAAG;IACrB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,iBAAiB,CAAC;IACzB,OAAO,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;CACzC,+BA2FA;AA6BD,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,sBAAsB,CAAA;CAAE,+BAiC3E;AAED,qEAAqE;AACrE,wBAAgB,QAAQ,CAAC,EACvB,OAAO,EACP,QAAQ,EACR,GAAG,GACJ,EAAE;IACD,OAAO,EAAE,sBAAsB,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,sCA0BA;AAED,iDAAiD;AACjD,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,OAAO,EACP,KAAK,EACL,QAAQ,EACR,OAAO,EACP,OAAO,GACR,EAAE;IACD,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,EAAE,sBAAsB,CAAC;IAChC,KAAK,EAAE,iBAAiB,CAAC;IACzB,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC7C,OAAO,IAAI,IAAI,CAAC;CACjB,+BAsDA"}

package/dist/ui/kit/FieldMenu.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { FieldGroupDefinition } from '../../model/index.js';
+/**
+ * A picker's entries by group: the fields outside any group first, then
+ * each group under its label. The definition says which group a field is
+ * in; this only lays them out, the same way in every picker that lists
+ * fields, so a user finds a field in the same place whether adding a
+ * condition, a column or a grouping.
+ *
+ * A searchable combobox of one-shot picks lived here too, until the
+ * condition editor's field list became a set of ticks a user works through
+ * without the list closing (`filter/FieldChecklist.tsx`). Nothing picks a
+ * field one at a time any more, so it is gone rather than kept for a caller
+ * that does not exist.
+ */
+export declare function GroupedMenu<T>({ items, groups, itemKey, render, }: {
+    items: readonly T[];
+    groups: readonly FieldGroupDefinition[];
+    itemKey(item: T): string;
+    render(item: T): ReactNode;
+}): import('react').JSX.Element;
+//# sourceMappingURL=FieldMenu.d.ts.map

package/dist/ui/kit/FieldMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldMenu.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/FieldMenu.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AASjE;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAC7B,KAAK,EACL,MAAM,EACN,OAAO,EACP,MAAM,GACP,EAAE;IACD,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC;IACpB,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACxC,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC;IACzB,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC;CAC5B,+BAqBA"}

package/dist/ui/kit/HandOffMenu.d.ts

@@ -0,0 +1,29 @@
+import { ComponentProps } from 'react';
+import { DropdownMenu, DropdownMenuItem } from '../components/dropdown-menu.js';
+import { DropdownMenuContent } from './popups.js';
+/**
+ * A menu some of whose items open something that takes the keyboard — a
+ * dialog, a box to type a name in (U-01).
+ *
+ * A menu gives the keyboard back to its trigger as it closes, and it closes
+ * *after* the item's dialog has opened: its exit animation runs on for a
+ * moment, then its focus manager puts the keyboard on the trigger — behind
+ * the dialog, which is modal, on the board it covers. What was typed went
+ * to the board. So an item that opens something says so
+ * (`DialogMenuItem`), and the menu then leaves the keyboard where it went;
+ * every other item, and Escape, still hand it back to the trigger.
+ *
+ * `HandOffMenu` is the menu's root, `HandOffMenuContent` its popup, and the
+ * two read one flag, reset each time the menu opens.
+ */
+export declare function HandOffMenu({ onOpenChange, ...props }: ComponentProps<typeof DropdownMenu>): import('react').JSX.Element;
+/** The popup of a `HandOffMenu`: back to the trigger unless an item handed off. */
+export declare function HandOffMenuContent(props: Omit<ComponentProps<typeof DropdownMenuContent>, 'finalFocus'>): import('react').JSX.Element;
+/**
+ * A menu item that opens a dialog, or anything else that takes the
+ * keyboard as it appears: the menu closing after it leaves the keyboard
+ * there. Whatever it opened hands the keyboard back when it closes, to the
+ * control it names (`FinalFocus`).
+ */
+export declare function DialogMenuItem({ onClick, ...props }: ComponentProps<typeof DropdownMenuItem>): import('react').JSX.Element;
+//# sourceMappingURL=HandOffMenu.d.ts.map

package/dist/ui/kit/HandOffMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HandOffMenu.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/HandOffMenu.tsx"],"names":[],"mappings":"AAaA,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAQlD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,EAC1B,YAAY,EACZ,GAAG,KAAK,EACT,EAAE,cAAc,CAAC,OAAO,YAAY,CAAC,+BAarC;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,IAAI,CAAC,cAAc,CAAC,OAAO,mBAAmB,CAAC,EAAE,YAAY,CAAC,+BAMtE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,GAAG,KAAK,EACT,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAAC,+BAWzC"}

package/dist/ui/kit/IconButton.d.ts

@@ -0,0 +1,74 @@
+import { Button } from '../components/button.js';
+import { TooltipContent } from './popups.js';
+import type * as React from 'react';
+/**
+ * A control that is nothing but an icon says its name on hover.
+ *
+ * D12 puts every function on a screen into an icon button, which leaves the
+ * name of each one somewhere only a screen reader goes. So the name is said
+ * twice over one string: `aria-label` for the reader, a tooltip for the
+ * pointer. **One message, two channels** — a call site that writes a second
+ * wording has written a second name for the same control, and the two will
+ * drift.
+ *
+ * This is the one place that pairs them, so "which buttons have a tooltip"
+ * stops being a question about call sites. `test/iconTooltips.test.tsx`
+ * holds the rule against the rendered DOM: any button on a workbench whose
+ * only content is an icon must carry what a tooltip's trigger stamps on
+ * whatever it renders.
+ *
+ * Not every icon button is a plain `Button` — a popup's trigger already
+ * renders one, and a segmented switch renders its own item. `IconTooltip`
+ * takes that element as it is; `IconButton` is the shorthand for the common
+ * case where there is nothing between the tooltip and the button.
+ */
+export interface IconTooltipProps {
+    /** The control's name, said to a reader and shown to a pointer. */
+    label: string;
+    /** The element the tooltip hangs off — already a button of some kind. */
+    render: React.ReactElement<Record<string, unknown>>;
+    /** Which side the tooltip takes; `top` unless the room is elsewhere. */
+    side?: React.ComponentProps<typeof TooltipContent>['side'];
+    /**
+     * While true, nothing opens. A drag handle is the case: the pointer is
+     * holding the row, and a black label following it round the list says
+     * nothing the user does not already know while making the drop harder to
+     * see. Keyboard focus still shows it, which is where a handle's name is
+     * needed most — the arrows it answers are not written anywhere else.
+     */
+    silent?: boolean;
+    children?: React.ReactNode;
+}
+export declare function IconTooltip({ label, render, side, silent, children, }: IconTooltipProps): React.JSX.Element;
+export interface IconButtonProps extends Omit<React.ComponentProps<typeof Button>, 'render'> {
+    /** The button's name, said to a reader and shown to a pointer. */
+    label: string;
+    /** Which side the tooltip takes; `top` unless the room is elsewhere. */
+    side?: IconTooltipProps['side'];
+    /** While true, no tooltip opens — see `IconTooltipProps.silent`. */
+    silent?: boolean;
+}
+/**
+ * An icon button and its tooltip, over one name.
+ *
+ * Everything a `Button` takes passes through — `variant`, `size`, `ref`,
+ * `disabled`, the data attributes a test looks for — because this adds a
+ * name and a tooltip and decides nothing else about the control.
+ */
+export declare function IconButton({ label, side, silent, children, ...button }: IconButtonProps): React.JSX.Element;
+export interface BadgeTooltipProps {
+    /** What the badge's words leave out, said on hover, focus and a tap. */
+    note: string;
+    /** The badge, rendering a button so the keyboard and a tap reach it. */
+    render: React.ReactElement<Record<string, unknown>>;
+    children?: React.ReactNode;
+}
+/**
+ * A badge with more to say than its words — 「点击筛选「仓库」」 and what a
+ * press then does — said the way every other hint here is (D16-6): a
+ * tooltip that focus and a tap open too, rather than a `title` only a
+ * mouse ever sees (U-11). The badge keeps its words as its name, and the
+ * note is its description, so a reader hears both.
+ */
+export declare function BadgeTooltip({ note, render, children }: BadgeTooltipProps): React.JSX.Element;
+//# sourceMappingURL=IconButton.d.ts.map

package/dist/ui/kit/IconButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconButton.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/IconButton.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpD,wEAAwE;IACxE,IAAI,CAAC,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;IAC3D;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,MAAM,EACN,IAAI,EACJ,MAAM,EACN,QAAQ,GACT,EAAE,gBAAgB,qBAgBlB;AAED,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAC3C,KAAK,CAAC,cAAc,CAAC,OAAO,MAAM,CAAC,EACnC,QAAQ,CACT;IACC,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChC,oEAAoE;IACpE,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,GAAG,MAAM,EACV,EAAE,eAAe,qBAWjB;AAED,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,iBAAiB,qBAazE"}

package/dist/ui/kit/MessagesProvider.d.ts

@@ -0,0 +1,135 @@
+import { ReactNode } from 'react';
+import { Issue } from '../../model/index.js';
+import { MessageKey, ViewMessages } from './messages.js';
+/**
+ * Hands the words `engine` was built with down to what shows its
+ * definitions (`useSay`): a Provider does for its engine, and a surface
+ * given an engine of its own does for that one.
+ */
+export declare function StartingWords({ engine, children, }: {
+    engine: {
+        startingWord(key: string): string | undefined;
+    } | undefined;
+    children: ReactNode;
+}): import('react').JSX.Element;
+export interface MessagesProviderProps {
+    /**
+     * Merged over the wording already in force, so an application overrides
+     * what it cares to: the defaults, or what an outer provider set.
+     */
+    messages?: ViewMessages;
+    /**
+     * The language the numbers in that wording are grouped in; the outer
+     * provider's when left out, and the runtime's when none sets one.
+     * `ViewSurface` passes its own `locale` here.
+     */
+    locale?: string;
+    children: ReactNode;
+}
+/**
+ * The wording every default component reads.
+ *
+ * `ViewSurface` renders it, so passing `messages` there is enough; this exists
+ * on its own for a host that builds its own surface out of the components.
+ * Each provider merges over the one above it, not over the defaults: an
+ * application that sets its wording once around its views keeps it inside
+ * every surface, where a reset used to put the defaults back.
+ */
+export declare function MessagesProvider({ messages, locale, children, }: MessagesProviderProps): import('react').JSX.Element;
+/**
+ * The wording in force here with `messages` merged over it, as a
+ * `MessagesProvider` given them would hand its children: what
+ * `ViewHost` says a definition's keys in.
+ */
+export declare function useMergedMessages(messages?: ViewMessages): ViewMessages;
+/** A definition's words as they are shown; see `useSay`. */
+export type Say = (value: string) => string;
+/**
+ * How a definition's keys (`text(key)`) are said here: in the wording in
+ * force — the nearest provider's `messages`, merged over the ones above —
+ * else in the words the engine was built with, else as the key itself
+ * (D2). Every label a definition carries passes through this where it is
+ * shown or leaves the engine — a cell, a chart's option, an export, an
+ * accessible name — and nowhere else: the state, the snapshots and what an
+ * editor takes and gives back keep their keys. A change of language is a
+ * new function, so what reads it draws again.
+ */
+export declare function useSay(messages?: ViewMessages): Say;
+/**
+ * `value` with every string in it as `say` shows it: a drawing's input —
+ * a chart's series, lines and stages, its spec's axis names — said as it
+ * reaches the code that draws it, and never kept (D2). The same object
+ * where nothing in it is a key; a class instance, a `Date` or a `Map` is
+ * left as it is.
+ */
+export declare function sayAll<T>(value: T, say: Say): T;
+/**
+ * What an editor gives back for a label it showed as `say(original)`: the
+ * original — a key stays a key — where the reader left the words as they
+ * were shown, else what they typed. An editor takes a key and shows it in
+ * words; it must not hand the words back as though the reader wrote them,
+ * or the label would stop following the language.
+ *
+ * `shown` is the words the box opened on, for a box that keeps a draft of
+ * its own: the language may change while it is open, and a draft left as
+ * it opened is still the original, whichever language it was said in.
+ */
+export declare function keptKey(typed: string, original: string, say: Say, shown?: string): string;
+/**
+ * A box that edits a label as it is typed: what it shows — `value` in
+ * words — and what a keystroke gives back (`keptKey`, against the value the
+ * box opened on), so words typed back to what was shown are the key again.
+ *
+ * A `value` the box did not give back itself — another row's, after the
+ * list it sits in lost one; an undo — opens it again on that value.
+ */
+export declare function useSaidText(value: string | undefined): {
+    shown: string;
+    back(typed: string): string;
+};
+/** The language set by the nearest provider that set one. */
+export declare function useInheritedLocale(): string | undefined;
+/** What a component needs: a label by key, an issue or a list as a sentence. */
+export interface MessageFormatters {
+    /**
+     * Wording by key. `fallback` is for text a component can derive itself:
+     * an operator reads acceptably as `between` without a catalogue entry and
+     * not at all as `ids`, so the catalogue names the ones worth naming and the
+     * rest fall back rather than printing their key.
+     *
+     * The key is one this package ships (`MessageKey`), so a component cannot
+     * ask for wording the catalogue does not carry. A host's own keys are read
+     * by the host, from its own map, not through here.
+     */
+    label(key: MessageKey, params?: Issue['params'], fallback?: string): string;
+    issue(found: Issue): string;
+    issues(found: readonly Issue[]): string;
+    /**
+     * A definition's words as they are shown here (`useSay`): its keys
+     * (`text(key)`) said in this wording. `label`, `issue` and `issues` say
+     * the keys their parameters carry already.
+     */
+    say: Say;
+}
+/** A host's words with numbers and words put into them; see `useSayWith`. */
+export type SayWith = (value: string, params?: Issue['params']) => string;
+/**
+ * How a host's words with numbers and words in them are said here — a
+ * declared action's question, 「准备 {count} 条执行记录？」: `value` is a key
+ * (`text(key)`) or words, said in the wording in force, with `{name}`s
+ * filled from `params` (a parameter that is a key is said too), and a key's
+ * count said apart where its catalogue words it so (`key-one`), as the
+ * package's own sentences are. `messages` and `locale` are merged over the
+ * wording in force, as `useViewMessages` takes them, for a part drawn above
+ * the surface whose provider holds the host's words.
+ */
+export declare function useSayWith(messages?: ViewMessages, locale?: string): SayWith;
+/**
+ * The formatters for the wording in force here, with `messages` merged over
+ * it and its numbers grouped in `locale`. A workbench passes the wording and
+ * the language it hands its own surface: that surface's provider is below it,
+ * so without this the workbench's own alerts would miss the translation every
+ * component inside it gets, and count in the machine's language besides.
+ */
+export declare function useViewMessages(messages?: ViewMessages, locale?: string): MessageFormatters;
+//# sourceMappingURL=MessagesProvider.d.ts.map

package/dist/ui/kit/MessagesProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessagesProvider.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/MessagesProvider.tsx"],"names":[],"mappings":"AAaA,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAGL,KAAK,KAAK,EAEX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAKL,KAAK,UAAU,EACf,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAUvB;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,QAAQ,GACT,EAAE;IACD,MAAM,EAAE;QAAE,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,GAAG,SAAS,CAAC;IACtE,QAAQ,EAAE,SAAS,CAAC;CACrB,+BAWA;AASD,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,QAAQ,EACR,MAAM,EACN,QAAQ,GACT,EAAE,qBAAqB,+BAUvB;AAMD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,YAAY,GAAG,YAAY,CAEvE;AAED,4DAA4D;AAC5D,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAE5C;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,QAAQ,CAAC,EAAE,YAAY,GAAG,GAAG,CAInD;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC,CA0B/C;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,GAAG,EACR,KAAK,CAAC,EAAE,MAAM,GACb,MAAM,CAIR;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7B,CAoBA;AAUD,6DAA6D;AAC7D,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,SAAS,CAEvD;AAaD,gFAAgF;AAChF,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;OASG;IACH,KAAK,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5E,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;IAC5B,MAAM,CAAC,KAAK,EAAE,SAAS,KAAK,EAAE,GAAG,MAAM,CAAC;IACxC;;;;OAIG;IACH,GAAG,EAAE,GAAG,CAAC;CACV;AAKD,6EAA6E;AAC7E,MAAM,MAAM,OAAO,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC;AAE1E;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAuB5E;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,CAAC,EAAE,YAAY,EACvB,MAAM,CAAC,EAAE,MAAM,GACd,iBAAiB,CAmBnB"}

package/dist/ui/kit/MixedCheckbox.d.ts

@@ -0,0 +1,16 @@
+import { Checkbox } from '../components/checkbox.js';
+import type * as React from 'react';
+/**
+ * A checkbox that can say "some": checked, unchecked, or a dash when only
+ * part of what it stands for is picked.
+ *
+ * The registry's checkbox draws its one glyph, a check, whenever the box is
+ * checked or mixed, and fills only a checked one: a select-all over 2 of 20
+ * rows read as a dark ✓ on a white box — all of them, to a user about to act
+ * on the selection — while it said `aria-checked="mixed"` (second review
+ * R2-81). The registry file is vendored and not edited by hand (D16-8), so
+ * the mixed state is drawn here, one layer over it: filled as a checked box
+ * is, its check hidden, and a dash in the primary's ink in its place.
+ */
+export declare function MixedCheckbox({ className, ...props }: React.ComponentProps<typeof Checkbox>): React.JSX.Element;
+//# sourceMappingURL=MixedCheckbox.d.ts.map

package/dist/ui/kit/MixedCheckbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MixedCheckbox.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/MixedCheckbox.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,EAC5B,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,QAAQ,CAAC,qBAYvC"}

package/dist/ui/kit/OutcomeActions.d.ts

@@ -0,0 +1,78 @@
+import { Issue } from '../../model/index.js';
+import { WriteState } from '../../runtime/index.js';
+/**
+ * Where an outcome is being reported, which is the only thing the two callers
+ * disagree about.
+ *
+ * `view` is the band under the title bar of the view that owns the write, and
+ * `row` is the line under a row of the manager, for a write no open view owns.
+ * A row is one of many inside a dialog, so it is drawn as a plain line in the
+ * smaller type and with the smaller buttons; the view's is a framed band.
+ */
+export type OutcomeSurface = 'row' | 'view';
+/**
+ * The ways out this outcome is allowed to offer, as callbacks.
+ *
+ * An absent one is a button that is not drawn, which is how each caller says
+ * what it can actually do: the manager has nowhere to copy a view to, and the
+ * view offers a copy or an overwrite only where the user may make one.
+ */
+export interface OutcomeActionSet {
+    /** Conflict: adopt the server's copy and drop the local one. */
+    reload?(): void;
+    /** Conflict: put the local one over the server's. */
+    overwrite?(): void;
+    /**
+     * Conflict: put the same intent once more. Offered instead of the pair
+     * above by a caller that has already settled the conflict and kept what the
+     * user meant, so there is no write left to recover — only an intent to
+     * repeat. It replaces the pair rather than joining it.
+     */
+    resubmit?(): void;
+    /** Conflict: keep the local one as a copy, leaving the server's alone. */
+    copy?(): void;
+    /** Unknown: replay the same request and let the server deduplicate. */
+    retry?(): void;
+    /** Unknown: stop holding it. */
+    leave?(): void;
+    /** Rejected: acknowledge the refusal so the line can come down. */
+    dismiss?(): void;
+}
+export interface OutcomeActionsProps {
+    /** What the write came to; a write that landed has none of these. */
+    state: WriteState;
+    actions: OutcomeActionSet;
+    /**
+     * Whether a write is in flight. Commands run one at a time, so a second
+     * recovery addresses the same handle twice: the engine refuses it with
+     * `view.write.in-flight`, and the line would report that refusal as though
+     * the user's click had been the thing at fault.
+     */
+    pending?: boolean;
+    surface?: OutcomeSurface;
+}
+/**
+ * What became of a write, and the way out of it: one line and a row of
+ * buttons, shared by the open view's band and the manager's rows.
+ *
+ * It is one line rather than a block, because what is under it — a result, a
+ * list of views — is still the real one, and a banner that pushed it off
+ * screen would report a problem by causing a second. Nothing here times out:
+ * every outcome that needs a decision keeps its buttons until one is made.
+ */
+export declare function OutcomeActions({ state, actions, pending, surface, }: OutcomeActionsProps): import('react').JSX.Element;
+/**
+ * A refusal says why, and offers only the way to have done with it.
+ *
+ * Used for a `rejected` outcome, and directly by the open view for a command
+ * the engine turned down before dispatching it — that one leaves nothing
+ * pending, so it comes with no way out and needs none.
+ */
+export declare function RefusalLine({ issue, surface, disabled, onDismiss, }: {
+    issue: Issue;
+    surface?: OutcomeSurface;
+    disabled?: boolean;
+    /** Absent for a failure the engine holds nothing for. */
+    onDismiss?(): void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=OutcomeActions.d.ts.map

package/dist/ui/kit/OutcomeActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutcomeActions.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/OutcomeActions.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAOzD;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,MAAM,CAAC,IAAI,IAAI,CAAC;IAChB,qDAAqD;IACrD,SAAS,CAAC,IAAI,IAAI,CAAC;IACnB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,IAAI,CAAC;IAClB,0EAA0E;IAC1E,IAAI,CAAC,IAAI,IAAI,CAAC;IACd,uEAAuE;IACvE,KAAK,CAAC,IAAI,IAAI,CAAC;IACf,gCAAgC;IAChC,KAAK,CAAC,IAAI,IAAI,CAAC;IACf,mEAAmE;IACnE,OAAO,CAAC,IAAI,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,gBAAgB,CAAC;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,OAAO,EACP,OAAe,EACf,OAAgB,GACjB,EAAE,mBAAmB,+BA4GrB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,OAAgB,EAChB,QAAQ,EACR,SAAS,GACV,EAAE;IACD,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yDAAyD;IACzD,SAAS,CAAC,IAAI,IAAI,CAAC;CACpB,+BAqCA"}

package/dist/ui/kit/PendingDot.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Pinned to the corner of the bordered node it belongs to — a condition
+ * pill or a group block, both of which are `relative` for it.
+ */
+export declare const PENDING_AT_CORNER = "fve:absolute fve:-top-0.5 fve:-right-0.5";
+/**
+ * The one credential for "said, but not yet asked".
+ *
+ * A draft is only worth keeping apart from what ran if the difference is
+ * visible, and it is visible in one mark, drawn the same size wherever it
+ * appears: pinned to a condition's corner, in the editor's toggle beside
+ * the count of them, and on the Apply button itself. The three used to be
+ * three copies of `size-1.5 rounded-full`, which is three chances for one
+ * of them to end up a different dot.
+ *
+ * **It is named in exactly one of those places.** The pills carry the
+ * wording, because that is where the reader can act on it — a condition
+ * that has moved. The summaries beside a count and on a button sit next to
+ * words that already say it, and a dot that repeats them is the same
+ * sentence twice.
+ */
+export declare function PendingDot({ 
+/**
+ * Whether this dot is the one that says so. Left off, it is decorative
+ * and the words beside it do the talking.
+ */
+named, 
+/**
+ * `on-primary` for a dot drawn on a filled `primary` surface — the Apply
+ * button — where `primary` itself would be invisible.
+ */
+tone, 
+/** Layout only: where the dot is put, when it is put somewhere. */
+className, }: {
+    named?: boolean;
+    tone?: 'primary' | 'on-primary';
+    className?: string;
+}): import('react').JSX.Element;
+//# sourceMappingURL=PendingDot.d.ts.map

package/dist/ui/kit/PendingDot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PendingDot.d.ts","sourceRoot":"","sources":["../../../src/ui/kit/PendingDot.tsx"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,6CAA6C,CAAC;AAE5E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC;AACzB;;;GAGG;AACH,KAAK;AACL;;;GAGG;AACH,IAAgB;AAChB,mEAAmE;AACnE,SAAS,GACV,EAAE;IACD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,SAAS,GAAG,YAAY,CAAC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,+BAmBA"}