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

package/dist/ui/embed/EmbedHead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbedHead.d.ts","sourceRoot":"","sources":["../../../src/ui/embed/EmbedHead.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAGzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAM7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAKxE;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,OAAO,EACP,YAAY,EACZ,KAAK,EACL,QAAQ,GACT,EAAE;IACD,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,yEAAyE;IACzE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,YAAY,EAAE,iBAAiB,CAAC;IAChC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,sCA6CA;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,EAC9B,EAAE,EACF,UAAU,GACX,EAAE;IACD,EAAE,EAAE,cAAc,CAAC;IACnB,UAAU,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAAC;CACtC,+BAaA;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,cAE1B;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG;IAChD,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB,CASA;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,GAAG,EACH,OAAO,EACP,IAAI,GACL,EAAE;IACD,2EAA2E;IAC3E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,iDAAiD;IACjD,GAAG,IAAI,IAAI,CAAC;IACZ,oEAAoE;IACpE,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,iEAAiE;IACjE,IAAI,EAAE,OAAO,CAAC;CACf,+BA0BA"}

package/dist/ui/embed/EmbeddedAnalysis.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { DataViewConfig } from '../../model/index.js';
+import { ViewNavigation, ViewRuntime } from '../../runtime/index.js';
+/**
+ * An analysis view on a business page (D22): its chart or its table as the
+ * author saved it, and what it was asked under. In the interactive tier the
+ * reader may also switch between table and chart, order the table by a
+ * header, and press a group for the analysis view's own follow-up menu —
+ * each item opened through the host's route as a view nobody saved, under
+ * the page's narrowing as its scope (`usePanelFollowUps`, the same route a
+ * dashboard panel's menu takes). Nothing of it is saved.
+ */
+export declare function EmbeddedAnalysis({ runtime, interactive, onNavigate, head, notices, }: {
+    runtime: ViewRuntime<DataViewConfig>;
+    interactive: boolean;
+    onNavigate?: ((to: ViewNavigation) => void) | undefined;
+    head(actions: ReactNode): ReactNode;
+    notices: ReactNode;
+}): import('react').JSX.Element;
+//# sourceMappingURL=EmbeddedAnalysis.d.ts.map

package/dist/ui/embed/EmbeddedAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedAnalysis.d.ts","sourceRoot":"","sources":["../../../src/ui/embed/EmbeddedAnalysis.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAC9D,OAAO,KAAK,EAGV,cAAc,EACf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,WAAW,EACjB,MAAM,wBAAwB,CAAC;AAwBhC;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,WAAW,EACX,UAAU,EACV,IAAI,EACJ,OAAO,GACR,EAAE;IACD,OAAO,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IACrC,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,cAAc,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACxD,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,CAAC;IACpC,OAAO,EAAE,SAAS,CAAC;CACpB,+BA6GA"}

package/dist/ui/embed/EmbeddedRecord.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+import { RecordRow } from '../../record/index.js';
+import { RecordViewRuntime } from '../../runtime/index.js';
+import { RenderFailureHandler } from '../kit/RenderBoundary.js';
+import { RecordDetailOptions } from '../workbench/RecordParts.js';
+/**
+ * A record view on a business page (D22): its rows and what they were
+ * fetched under, and — as the host switched them on — its search, its
+ * export and, in the interactive tier, the header sort, the pages, — with
+ * the export — the row checks and — with `detail` — a record's detail,
+ * read-only (G20).
+ *
+ * `head` draws the embed's first row; the export is handed to it, since
+ * the button belongs there and the rows it takes are known only here.
+ */
+export declare function EmbeddedRecord({ runtime, interactive, withSearch, withExport, rowActions, detail: detailOptions, onRenderFailure, head, notices, }: {
+    runtime: RecordViewRuntime;
+    interactive: boolean;
+    withSearch: boolean;
+    withExport: boolean;
+    rowActions?: ((row: RecordRow) => ReactNode) | undefined;
+    /**
+     * The record detail, where the host switched it on and the tier allows
+     * it (`null` otherwise): who holds which record is open, and the host's
+     * sections in it.
+     */
+    detail: RecordDetailOptions | null;
+    onRenderFailure?: RenderFailureHandler | undefined;
+    head(actions: ReactNode): ReactNode;
+    /** What the view says about itself, under the head. */
+    notices: ReactNode;
+}): import('react').JSX.Element;
+//# sourceMappingURL=EmbeddedRecord.d.ts.map

package/dist/ui/embed/EmbeddedRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedRecord.d.ts","sourceRoot":"","sources":["../../../src/ui/embed/EmbeddedRecord.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAY,KAAK,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAmB1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,WAAW,EACX,UAAU,EACV,UAAU,EACV,UAAU,EACV,MAAM,EAAE,aAAa,EACrB,eAAe,EACf,IAAI,EACJ,OAAO,GACR,EAAE;IACD,OAAO,EAAE,iBAAiB,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,SAAS,KAAK,SAAS,CAAC,GAAG,SAAS,CAAC;IACzD;;;;OAIG;IACH,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACnC,eAAe,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACnD,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,CAAC;IACpC,uDAAuD;IACvD,OAAO,EAAE,SAAS,CAAC;CACpB,+BA6JA"}

package/dist/ui/embed/options.d.ts

@@ -0,0 +1,118 @@
+import { Ref } from 'react';
+import { ViewNavigation, ViewEngine } from '../../runtime/index.js';
+import { PanelHeadingLevel } from '../dashboard/DashboardPanel.js';
+import { ViewMessages } from '../kit/messages.js';
+import { RenderFailureHandler } from '../kit/RenderBoundary.js';
+import { ViewDensity, ViewPreset } from '../kit/presets.js';
+import { ViewSurfaceProps, ViewTheme } from '../kit/ViewSurface.js';
+/**
+ * How far a reader may go with an embed (D22, D36). Either way nothing is
+ * written: an embed never saves a view, a board or a preference — defining
+ * views, building boards and saving them are the workbenches' (D36).
+ *
+ * - `static` — what the page shows, as its author saved it: the rows, the
+ *   chart or the board and what they were fetched under; nothing on it
+ *   filters, sorts, pages, redraws or leads anywhere. The default, since a
+ *   business page shows what someone else set up (D24 Q21).
+ * - `interactive` — the reader may look closer, for this viewing only:
+ *   change a board's filters, sort by a header, page, switch an analysis
+ *   between table and chart, press a group (the follow-up menu, a board's
+ *   cross-filter), fill the screen where the host offers it (`expandable`)
+ *   and open the view in the workbench. None of it is saved; the ways off
+ *   the page go through the host's route (`onNavigate`).
+ */
+export type EmbedInteraction = 'static' | 'interactive';
+/**
+ * How tall an embed is.
+ *
+ * - `content` — as tall as what it shows, up to a cap, so a card on a
+ *   business page holds it: a record or an analysis table scrolls inside
+ *   `--fve-record-table-max-h` (70vh), a chart keeps its own height, a
+ *   dashboard is as tall as its rows. The default.
+ * - `fill` — the container's height, the result taking what the rest leaves
+ *   and scrolling inside it: a whole-page embed, a wall screen. The
+ *   container must have a height to give.
+ */
+export type EmbedSize = 'content' | 'fill';
+/** What both embeds take, the view or the board they show aside. */
+export interface EmbedBaseProps {
+    /** The engine; the `ViewHost`'s when left out. */
+    engine?: ViewEngine;
+    /** The saved view or board to show; a code-declared system one works too. */
+    instanceId: string;
+    /** How tall it is (`EmbedSize`); `content` by default. */
+    size?: EmbedSize;
+    /**
+     * Whether its title is drawn, as a heading at `headingLevel` (off by
+     * default): a page usually names what it embeds in its own words.
+     */
+    withTitle?: boolean;
+    /**
+     * The heading level of what the embed titles: its own title when drawn,
+     * and a dashboard's panels one level under it — or at it, with no title.
+     * `2` by default, under the host page's `h1`; only the host knows its
+     * outline.
+     */
+    headingLevel?: PanelHeadingLevel;
+    /**
+     * Whether it refreshes itself on the interval its author saved (on by
+     * default). Off, the timer never runs — a page that refreshes itself, or
+     * one printed — and nothing on screen offers it back.
+     */
+    autoRefresh?: boolean;
+    /**
+     * Whether 在工作台中打开 is offered — the view itself, or the view behind
+     * a panel — in the interactive tier, with a route to go by (on by
+     * default). The static tier never offers it.
+     */
+    openInWorkbench?: boolean;
+    /**
+     * The host's route: 在工作台中打开, the follow-up menu on a group and a
+     * panel's destination go through it (`ViewNavigation`). Without it —
+     * here, or the `ViewHost`'s `router` or `navigate` — none of them
+     * exist.
+     */
+    onNavigate?(to: ViewNavigation): void;
+    /** The mode, as `ViewSurface` takes it: follows the host when left out. */
+    theme?: ViewTheme;
+    /** A preset pinned on the surface and its popups (`ViewSurface`). */
+    preset?: ViewPreset;
+    /** How dense the tables, the view list and the panels sit (`ViewSurface`). */
+    density?: ViewDensity;
+    /**
+     * The host's own `--fve-*` for this surface and its popups alone
+     * (`ViewSurface`): beats any preset, the one pinned here included.
+     */
+    tokens?: ViewSurfaceProps['tokens'];
+    /** Wording, merged over what is already in force: where a host translates. */
+    messages?: ViewMessages;
+    /**
+     * The language dates and times show in; the runtime's when left out. It is
+     * the same choice as `messages`, made for values rather than words.
+     */
+    locale?: string;
+    className?: string;
+    /**
+     * 「铺满屏幕」 in the embed's first row, in the interactive tier (off by
+     * default): the surface fills the screen in place, as a workbench's does
+     * (`ViewExpandToggle`), and Escape or the same button puts it back. Off,
+     * the embed grows no such control (D10); the static tier never offers it.
+     */
+    expandable?: boolean;
+    /**
+     * The surface this draws on, handed back.
+     *
+     * Without `expandable` an embed grows no control of its own for filling
+     * the screen: a button floating over somebody's order page is chrome that
+     * page did not ask for (D10). A host that wants the control in its own
+     * chrome instead — or on a static embed — points `useViewExpansion` at
+     * the element it gets here.
+     */
+    ref?: Ref<HTMLDivElement>;
+    /**
+     * Told when the embed fails to draw — a row action of the host's that
+     * throws, for one. The embed shows a recoverable error state in place.
+     */
+    onRenderFailure?: RenderFailureHandler;
+}
+//# sourceMappingURL=options.d.ts.map

package/dist/ui/embed/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/ui/embed/options.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEzE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,aAAa,CAAC;AAExD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAE3C,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,UAAU,CAAC,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,2EAA2E;IAC3E,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,qEAAqE;IACrE,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB;;;OAGG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACpC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;IAC1B;;;OAGG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;CACxC"}

package/dist/ui/filter/AddEntry.d.ts

@@ -0,0 +1,25 @@
+import { FilterPath } from '../../filter/index.js';
+import { FilterTreeController } from '../../react/index.js';
+/**
+ * The way into a group: its fields, and — where the editor shows groups — a
+ * group to nest.
+ *
+ * The two are separate controls because they are separate kinds of thing.
+ * Nesting a group was the last entry of the field list while the list was a
+ * menu of one-shot picks; a list the user ticks several fields in has no
+ * place for an entry that is not a field, and an operator is not a field.
+ */
+export declare function AddEntry({ filter, parent, disabled, groups, label, name, pick, }: {
+    filter: FilterTreeController;
+    parent: FilterPath;
+    disabled?: boolean;
+    /** Whether groups may be added here: only the advanced editor shows them. */
+    groups: boolean;
+    /** The button's text; the catalogue's own when a caller names none. */
+    label?: string;
+    /** The accessible name, where it says more than the text (`FieldChecklist`). */
+    name?: string;
+    /** Opens the field list when it changes (`FieldChecklist`'s `pick`). */
+    pick?: number;
+}): import('react').JSX.Element;
+//# sourceMappingURL=AddEntry.d.ts.map

package/dist/ui/filter/AddEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AddEntry.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/AddEntry.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAejE;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,EACvB,MAAM,EACN,MAAM,EACN,QAAQ,EACR,MAAM,EACN,KAAK,EACL,IAAI,EACJ,IAAI,GACL,EAAE;IACD,MAAM,EAAE,oBAAoB,CAAC;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6EAA6E;IAC7E,MAAM,EAAE,OAAO,CAAC;IAChB,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,+BAuDA"}

package/dist/ui/filter/AppliedBar.d.ts

@@ -0,0 +1,39 @@
+import { FilterEditorController } from '../../react/index.js';
+export interface AppliedBarProps {
+    filter: FilterEditorController;
+    /**
+     * Whether a question has been put to the source — a result came back, one
+     * is on its way, or the last one failed (`hasAsked`). `filter.applied`
+     * describes the conditions it was put under, so an empty list means either
+     * "no condition" or "nothing asked yet" and the bar cannot tell the two
+     * apart on its own. The workbench knows — it holds the state — and says so
+     * here, which keeps the bar off the runtime.
+     */
+    asked: boolean;
+    disabled?: boolean;
+    /**
+     * Nothing here may be taken out of force. The ✕ is not rendered at all
+     * rather than rendered disabled: an embedded view shows what somebody
+     * already decided, and a control that is only ever grey offers a narrowing
+     * the reader will never be given.
+     */
+    readOnly?: boolean;
+    /**
+     * The view the rows belong to, which names the band as a landmark:
+     * 「正在显示：〈视图〉」. A page may hold two embeds, and two regions of
+     * one name are one place a reader hears twice (axe `landmark-unique`).
+     * Left out — the workbench, one view to a page — the band is 「正在显示」.
+     */
+    title?: string;
+    className?: string;
+}
+/**
+ * The conditions the rows below were fetched under.
+ *
+ * It is deliberately not the editor's draft: applying starts a query, and
+ * until that query answers the draft has already moved on. A bar that
+ * followed the draft would describe rows that are not on screen yet, which is
+ * worse than describing none.
+ */
+export declare function AppliedBar({ filter, asked, disabled, readOnly, title, className, }: AppliedBarProps): import('react').JSX.Element | null;
+//# sourceMappingURL=AppliedBar.d.ts.map

package/dist/ui/filter/AppliedBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppliedBar.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/AppliedBar.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AASnE,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,sBAAsB,CAAC;IAC/B;;;;;;;OAOG;IACH,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EACzB,MAAM,EACN,KAAK,EACL,QAAQ,EACR,QAAgB,EAChB,KAAK,EACL,SAAS,GACV,EAAE,eAAe,sCAoKjB"}

package/dist/ui/filter/ConditionPill.d.ts

@@ -0,0 +1,38 @@
+import { FieldOption, FilterLeaf } from '../../model/index.js';
+import { FilterPath } from '../../filter/index.js';
+import { FilterTreeController } from '../../react/index.js';
+/**
+ * One condition: a field, an operator and whatever value editor the kind
+ * implies, as one inline pill. Blank — a field chosen and nothing said yet —
+ * it is dashed; wrong, it is marked invalid. A condition that holds a tree
+ * is a block instead: its header is the same field and operator, its body
+ * the group it holds.
+ *
+ * A condition whose kind the registry does not know is drawn read-only. The
+ * picker cannot produce one (`fieldsFor`), so it only ever arrives from a
+ * stored config whose definition has since changed, and the only two things
+ * the user can do with it are read it and take it out — which is exactly
+ * what the read-only pill offers.
+ */
+export declare function ConditionPill({ filter, leaf, path, disabled, optionsFor, isPending, negatable, negated, }: {
+    filter: FilterTreeController;
+    leaf: FilterLeaf;
+    path: FilterPath;
+    disabled?: boolean;
+    optionsFor?: (remote: string) => FieldOption[] | undefined;
+    isPending?: (path: FilterPath) => boolean;
+    /**
+     * Whether the pill offers its negation switch (D18-7). Simple mode's
+     * strip does; advanced mode has the group operator for the same thing,
+     * and a switch beside a "None of" header would say it twice.
+     */
+    negatable?: boolean;
+    /**
+     * True when this condition is held as "not this". The pill says so and
+     * offers to undo it; what the tree stores it as is the kernel's, and
+     * `path` is this condition's path either way — `remove` takes out the
+     * whole of it without this component knowing there is a wrapper.
+     */
+    negated?: boolean;
+}): import('react').JSX.Element;
+//# sourceMappingURL=ConditionPill.d.ts.map

package/dist/ui/filter/ConditionPill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionPill.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/ConditionPill.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EAIX,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAOL,KAAK,UAAU,EAChB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAiCjE;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,SAAS,EACT,SAAS,EACT,OAAO,GACR,EAAE;IACD,MAAM,EAAE,oBAAoB,CAAC;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,WAAW,EAAE,GAAG,SAAS,CAAC;IAC3D,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC;IAC1C;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,+BA4XA"}

package/dist/ui/filter/FieldChecklist.d.ts

@@ -0,0 +1,56 @@
+import { FilterPath } from '../../filter/index.js';
+import { FilterTreeController } from '../../react/index.js';
+/**
+ * The fields of a group, as a grid of checkboxes to tick rather than a menu
+ * to pick from.
+ *
+ * Building a filter is choosing several fields, and a menu that closed on
+ * each one made that four round trips for four conditions. The list stays
+ * open instead: a tick adds the condition, and clearing a tick takes it away
+ * again — which the design's one rule about groups makes unambiguous, since
+ * a group holds at most one condition per field and there is never a second
+ * one to wonder about. A field that already holds a value is no exception:
+ * the tick is the condition's existence, and a user who unticks one is
+ * asking for it to go.
+ *
+ * **Every field wears a visible checkbox**, and the grid runs in two columns
+ * wherever the popup is wide enough. D16 had replaced that grid with a Base
+ * UI `Combobox multiple` for the list keyboard model it brought for free;
+ * measured on a definition with 21 fields, what it cost was worse than what
+ * it bought — one column showed 7 of them at a time, and the unticked ones
+ * carried no mark at all next to the ticked ones' ✓, so the list read as a
+ * menu of single picks. The user ruled on 2026-09-21 that the grid comes
+ * back, and D16 records the exception. What this round kept from the
+ * combobox is the part that earned its place on a wide definition: the
+ * search line at the top (it narrows every group at once and drops the ones
+ * left empty), the grouping, and the empty sentence.
+ *
+ * Each field is the registry's `Checkbox` inside a `Field` — one tab stop,
+ * Space to toggle, its own label — and each catalogue group is a `FieldSet`
+ * under its `FieldLegend`, which is the registry's own part for a set of
+ * related checkboxes. The catalogue is laid out exactly as every other field
+ * picker lays it out — ungrouped fields first and without a heading, then
+ * each declared group — so a field is found in the same place whether it is
+ * being added as a condition, a column or a grouping.
+ */
+export declare function FieldChecklist({ filter, parent, disabled, label, name, pick, }: {
+    filter: FilterTreeController;
+    parent: FilterPath;
+    disabled?: boolean;
+    /** The button's text, and its accessible name unless `name` says more. */
+    label: string;
+    /**
+     * The accessible name, where the text alone would not tell two of these
+     * apart: a metric's condition block and the range both say 「添加条件」,
+     * and the name says whose (「金额的总和 添加条件」). It keeps the text in
+     * it, so what a reader hears is what a sighted user reads, plus whose.
+     */
+    name?: string;
+    /**
+     * Opens the list when it changes to a new number: a press elsewhere that
+     * means 「pick a field」 — the empty result's 「添加条件」 — lands here
+     * rather than one Tab short of it. `0`, the default, opens nothing.
+     */
+    pick?: number;
+}): import('react').JSX.Element;
+//# sourceMappingURL=FieldChecklist.d.ts.map

package/dist/ui/filter/FieldChecklist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldChecklist.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/FieldChecklist.tsx"],"names":[],"mappings":"AAgBA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AA8BjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,MAAM,EACN,QAAQ,EACR,KAAK,EACL,IAAI,EACJ,IAAI,GACL,EAAE;IACD,MAAM,EAAE,oBAAoB,CAAC;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,+BA4OA"}

package/dist/ui/filter/FilterActions.d.ts

@@ -0,0 +1,49 @@
+import { FilterEditorController } from '../../react/index.js';
+/**
+ * The ways an edit can end, and the count that stands in the way of one.
+ *
+ * Apply is the one primary button on the screen — submitting is explicit, and
+ * nothing in the panel re-runs the query by itself. It keeps that weight even
+ * where a second submit button stands beside it: the analysis editor's Run
+ * calls the same `runtime.apply()`, so it is one execution with two ways in,
+ * and it is drawn `outline` rather than promoted to a second primary
+ * (D17-3). Where the edits run on their own it may rest as an outline
+ * (`quiet`) until something waits for it. Discard is the other end of the
+ * same decision and appears only
+ * when there is an edit to discard, so the row never offers to undo nothing.
+ */
+export declare function FilterActions({ filter, disabled, overBudget, pending, quiet, words, onApply, }: {
+    filter: FilterEditorController;
+    disabled?: boolean;
+    /**
+     * Whether the draft holds something the last run did not. The filter's
+     * own reading by default; an editor that runs more than the filter — the
+     * analysis tray — says so for the whole draft.
+     */
+    pending?: boolean;
+    /**
+     * Whether the stored tree broke the depth or node budget. Such a tree may
+     * hold no leaf at all — deep groups — and clearing it is then the only way
+     * back to an editable filter.
+     */
+    overBudget: boolean;
+    /**
+     * Whether Apply may rest as an outline button while nothing is `pending`:
+     * the editor runs its edits on its own (the analysis tray's auto-run), so
+     * a filled button would ask for a press that does nothing new. It is
+     * primary again the moment something waits for it.
+     */
+    quiet?: boolean;
+    /**
+     * What the conditions are called where these stand: a record view's
+     * filter, or an analysis's range — the tray says 「范围」 over them, and
+     * 「放弃筛选修改」 under it read as undoing the whole tray.
+     */
+    words?: 'filter' | 'range';
+    /**
+     * What Apply does, where a caller has something to settle first; the
+     * filter's own `submit` when left out.
+     */
+    onApply?(): void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=FilterActions.d.ts.map

package/dist/ui/filter/FilterActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterActions.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/FilterActions.tsx"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAQnE;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,QAAQ,EACR,UAAU,EACV,OAAwB,EACxB,KAAa,EACb,KAAgB,EAChB,OAAO,GACR,EAAE;IACD,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAC3B;;;OAGG;IACH,OAAO,CAAC,IAAI,IAAI,CAAC;CAClB,+BAoGA"}

package/dist/ui/filter/FilterModes.d.ts

@@ -0,0 +1,39 @@
+import { FilterEditorController } from '../../react/index.js';
+import { useViewMessages } from '../kit/MessagesProvider.js';
+/**
+ * Whether the condition editor shows one strip of conditions or the whole
+ * tree, as the two items of the editor's own menu.
+ *
+ * The mode is a way of *editing* rather than part of the filter, which is
+ * why it left the panel: the panel is the conditions, and everything about
+ * how they are edited now hangs off the one toggle in the title bar.
+ *
+ * What it shows is the mode in force, not the mode stored. A config saved as
+ * simple may hold a group, which the simple editor cannot draw faithfully,
+ * and the editor opens advanced regardless; the menu says so — and says why
+ * simple is not on offer — rather than claiming a mode the editor below is
+ * not in.
+ */
+export declare function FilterModes({ filter }: {
+    filter: FilterEditorController;
+}): import('react').JSX.Element;
+/**
+ * The same choice, as a control inside the panel.
+ *
+ * It is what a surface falls back on when it has nowhere better to put the
+ * mode. A workbench whose only editor *is* this panel does have somewhere
+ * better — the fold's toggle in the title bar — but one whose editor is this
+ * panel and something else besides cannot fold them both under the word
+ * "Filter", so the choice stays here rather than going missing. A mode that
+ * exists but cannot be reached is a capability the user has lost.
+ *
+ * Two short options, so a segmented control rather than a row of separate
+ * buttons — `spacing={0}`, and the house rule in `docs/design/ui`.
+ */
+export declare function FilterModeToggle({ filter, disabled, }: {
+    filter: FilterEditorController;
+    disabled?: boolean;
+}): import('react').JSX.Element;
+/** The mode in force, for the editor toggle's name. */
+export declare function filterModeLabel(filter: FilterEditorController, messages: ReturnType<typeof useViewMessages>): string;
+//# sourceMappingURL=FilterModes.d.ts.map

package/dist/ui/filter/FilterModes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterModes.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/FilterModes.tsx"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAOnE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAqB7D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,sBAAsB,CAAA;CAAE,+BAqCzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,MAAM,EACN,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,+BAuCA;AAiBD,uDAAuD;AACvD,wBAAgB,eAAe,CAC7B,MAAM,EAAE,sBAAsB,EAC9B,QAAQ,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,GAC3C,MAAM,CAMR"}

package/dist/ui/filter/FilterPanel.d.ts

@@ -0,0 +1,76 @@
+import { FocusEvent } from 'react';
+import { FieldOption } from '../../model/index.js';
+import { FilterEditorController } from '../../react/index.js';
+export interface FilterPanelProps {
+    filter: FilterEditorController;
+    /** Candidates for a `remote` value editor, by the key its kind declared. */
+    optionsFor?(remote: string): FieldOption[] | undefined;
+    disabled?: boolean;
+    /**
+     * Whether the panel carries its own way out. An editor that is applied
+     * from elsewhere — a dashboard's global band, a host's own button — keeps
+     * the fields to add with and loses the pair that would run the query
+     * twice.
+     */
+    submit?: boolean;
+    /**
+     * Whether the panel carries its own control over the editing mode.
+     *
+     * False where the surface around it has a better place for one — a
+     * workbench whose only editor is this panel puts it on the fold's toggle
+     * in the title bar. True, the default, everywhere else: a workbench whose
+     * editor is this panel *and something else* cannot fold both under the
+     * word "Filter", and a mode that exists but cannot be reached is a
+     * capability the user has lost rather than a tidier screen.
+     */
+    modes?: boolean;
+    /**
+     * Opens the root's field list when it changes to a new number: the empty
+     * result's 「添加条件」 is a request for a field, and it lands in the list
+     * rather than on the fold that holds it. `0` or left out opens nothing.
+     */
+    pick?: number;
+}
+/**
+ * The condition builder. A group is a framed block: its operator, its
+ * conditions and room to add. A condition is a compact inline pill — field,
+ * operator, value editor — and a group's conditions wrap in one strip, so a
+ * filter of five conditions reads in a line rather than five rows. A
+ * condition that holds a tree (an element match) is a block like a group,
+ * since it is one. Simple mode shows the root's conditions as one strip;
+ * anything the simple editor cannot show faithfully — a group anywhere — gets
+ * the advanced one, where groups can be flipped between and/or, nested,
+ * filled and removed. Where the surface around the panel has a place for the
+ * mode — the fold's toggle in a workbench whose only editor is this panel —
+ * it takes it (`modes={false}`), because a control for *how* to edit sitting
+ * among the conditions was a line of chrome over every filter ever written.
+ * Where it has not, the panel keeps its own: a mode that exists but cannot be
+ * reached is a capability lost, not a tidier screen.
+ *
+ * Nothing is applied until submit, which is the whole point of keeping a
+ * draft apart from what ran: typing in here never re-queries. Enter in a
+ * value editor is the one shortcut to that submit — the same command the
+ * Apply button runs, refused under the same conditions.
+ */
+export declare function FilterPanel({ filter, optionsFor, disabled, submit, modes, pick, }: FilterPanelProps): import('react').JSX.Element;
+/**
+ * Whether a focus event entered or left the element it was handled on, as
+ * opposed to moving between two of its descendants. `relatedTarget` is the
+ * other side of the move: on focus the element left, on blur the one gained.
+ */
+export declare function crossesBoundary(event: FocusEvent<HTMLElement>): boolean;
+/**
+ * Whether a blur means the user left the editor. A select, a date picker or
+ * a menu of one of its controls renders in a portal outside the element, and
+ * focus in there is still focus in the editor. Base UI marks the trigger of
+ * an open popup, so the editor can tell one of its own is open; when it
+ * closes, focus returns to the trigger and a later blur is judged afresh.
+ * A tooltip is not one: it takes no focus, it is open only because its
+ * trigger has focus — the very focus that is leaving — and counting it held
+ * the editor "editing" after a blur from an icon button or an ⓘ. But one
+ * button can be both, a menu's trigger that also carries a tooltip
+ * (「添加分组」, a tray card's ⋮): while its menu is open it says so with
+ * `aria-expanded`, and focus in that menu is still focus in the editor.
+ */
+export declare function leavesEditor(event: FocusEvent<HTMLElement>): boolean;
+//# sourceMappingURL=FilterPanel.d.ts.map

package/dist/ui/filter/FilterPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterPanel.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/FilterPanel.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,UAAU,EAAiB,MAAM,OAAO,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAcnE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,sBAAsB,CAAC;IAC/B,4EAA4E;IAC5E,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CAAC,EAC1B,MAAM,EACN,UAAU,EACV,QAAQ,EACR,MAAa,EACb,KAAY,EACZ,IAAI,GACL,EAAE,gBAAgB,+BAuJlB;AAYD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAEvE;AAuCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAIpE"}