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

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

@@ -0,0 +1,103 @@
+import { FieldKindId, FieldOption, FilterValue } from '../../model/index.js';
+import { EditorDescriptor } from '../../filter/index.js';
+import { OptionSource, ValueCandidateSource } from '../../runtime/index.js';
+import { ControlAria } from './inputs/shared.js';
+/**
+ * A number field that lets a half-typed number stay half typed. Lives with
+ * the number input; re-exported here because the analysis editor uses it for
+ * its own limits, which are numbers without being filter values.
+ */
+export { NumberInput } from './inputs/number.js';
+export interface FilterValueEditorProps {
+    /** What the field's kind says this operator needs. */
+    editor: EditorDescriptor;
+    /**
+     * The kind that produced the descriptor. Only the fallback reads it, to
+     * name the kind in the sentence saying why nothing here can be edited.
+     */
+    kind: FieldKindId;
+    value: FilterValue;
+    onChange(value: FilterValue): void;
+    label: string;
+    disabled?: boolean;
+    /**
+     * Whether the condition this value belongs to has been refused, which the
+     * controls carry as `aria-invalid`: the pill's own `data-invalid` is a
+     * border, and a border is not something a screen reader reads out.
+     */
+    invalid?: boolean;
+    /**
+     * Whether the value is never blank — a board's starred filter, whose
+     * default comes back the moment it is emptied. A control that passes
+     * through nothing on its way to a new answer (a date turned into a
+     * calendar date not yet picked) then keeps the value in force until the
+     * new one is given, rather than having its step undone under it.
+     */
+    required?: boolean;
+    /** Every candidate of a `remote` editor at once, where a host holds the whole list. */
+    options?: FieldOption[];
+    /**
+     * The searchable source behind a `remote` editor, from the runtime. With
+     * neither this nor `options`, the value is typed.
+     */
+    source?: OptionSource | null;
+    /**
+     * The field's own values, counted from the data, behind a `text` editor
+     * (`FilterTreeController.valueCandidates`). With it the text is typed or
+     * picked from them; without it, typed.
+     */
+    candidates?: ValueCandidateSource | null;
+    /**
+     * What an empty typed box says instead of 「未设置」 — a board's search
+     * filter says 「搜索…」, since an empty search is not a missing value but
+     * the invitation to type one.
+     */
+    placeholder?: string;
+    /**
+     * The times a `duration` editor's gap may run from (N3): the other time
+     * fields beside the condition's own, from the pill that holds it.
+     */
+    times?: readonly {
+        value: string;
+        label: string;
+    }[];
+    /**
+     * A date held to one day (`DashboardField.oneDay`): one calendar day, or
+     * one of the days by name that have come.
+     */
+    oneDay?: boolean;
+    /**
+     * The words for a date that holds nothing, offered as a choice of its
+     * own where the value may be blank — a board's optional date filter.
+     */
+    blank?: string;
+    /** Told whether a date control asks for a day its value does not hold. */
+    onAwaiting?: (awaiting: boolean) => void;
+    /**
+     * A form's word on its control (`ControlAria`): a visible label's id, a
+     * hint, a value it cannot go without. A text, a number, a yes/no and a
+     * list of options carry it — the controls a declared action's form draws.
+     */
+    control?: ControlAria;
+}
+/**
+ * One value control, chosen by the descriptor the field kind produced.
+ *
+ * The kind decides the shape of a value and the editor it implies; this
+ * component only renders that decision, which is why a custom kind needs no
+ * change here beyond a renderer for a shape it invents.
+ *
+ * This switch is the one place that knows `EditorDescriptor.input` is a
+ * closed union — every control behind it takes plain props and knows nothing
+ * of the descriptor. That is the seam a per-kind renderer registry would be
+ * cut along (docs/design/extension.md); until there is one, a kind picks one
+ * of the members, and a shape outside the union has no control at all. It
+ * used to fall through to a plain text input, which was the one answer the
+ * extension point promises not to give: a kind that invented a value shape
+ * had it quietly overwritten with a string by an editor that did not
+ * understand it. The fallback now reads the value out and says nothing can
+ * edit it, and admission refuses the condition for the same reason
+ * (`filter.kind.unknown-editor`), so Apply does not run it either.
+ */
+export declare function FilterValueEditor(props: FilterValueEditorProps): import('react').JSX.Element;
+//# sourceMappingURL=FilterValueEditor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FilterValueEditor.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/FilterValueEditor.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,WAAW,EACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAK9D,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAKhC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAItD;;;;GAIG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,WAAW,sBAAsB;IACrC,sDAAsD;IACtD,MAAM,EAAE,gBAAgB,CAAC;IACzB;;;OAGG;IACH,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uFAAuF;IACvF,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B;;;;OAIG;IACH,UAAU,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACzC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,KAAK,CAAC,EAAE,SAAS;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACpD;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;IACzC;;;;OAIG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,+BAiB9D"}

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

@@ -0,0 +1,49 @@
+import { FieldOption, FilterGroup } from '../../model/index.js';
+import { FilterPath } from '../../filter/index.js';
+import { FilterTreeController } from '../../react/index.js';
+/** One group as a framed block: its operator, its children, room to add. */
+export declare function GroupBlock({ filter, group, path, disabled, optionsFor, scope, isPending, pick, }: {
+    filter: FilterTreeController;
+    group: FilterGroup;
+    path: FilterPath;
+    disabled?: boolean;
+    optionsFor?: (remote: string) => FieldOption[] | undefined;
+    /** Opens this group's field list when it changes (`FieldChecklist`). */
+    pick?: number;
+    /**
+     * Whether the node at a path has been edited since the last apply. Only
+     * the editor bound to a view has an applied tree to compare against; a
+     * predicate's editor writes into a leaf and has none, so it passes none.
+     */
+    isPending?: (path: FilterPath) => boolean;
+    /**
+     * What this group is a group of, for the controls' accessible names. A
+     * predicate renders a second root group on the same screen as the view's
+     * own, and two controls called "Group operator" are two controls a screen
+     * reader cannot tell apart.
+     */
+    scope?: string;
+}): import('react').JSX.Element;
+/**
+ * A group's conditions in one strip: a grid of equal columns, as many as
+ * fit, so the pills line up and their fields, operators and values fall
+ * under one another. A nested group, and a condition that holds a tree,
+ * takes a whole line of its own, since it holds conditions of its own.
+ */
+export declare function ConditionStrip({ filter, group, path, disabled, optionsFor, scope, isPending, negatable, }: {
+    filter: FilterTreeController;
+    group: FilterGroup;
+    path: FilterPath;
+    disabled?: boolean;
+    optionsFor?: (remote: string) => FieldOption[] | undefined;
+    scope?: string;
+    isPending?: (path: FilterPath) => boolean;
+    /**
+     * Simple mode's strip: every pill offers its negation switch, and a
+     * condition alone in a `nor` group is drawn as that pill, pressed, rather
+     * than as the group it is stored as. Advanced mode leaves this off and
+     * shows the group — the tree as it is, with the operator to change it.
+     */
+    negatable?: boolean;
+}): import('react').JSX.Element | null;
+//# sourceMappingURL=GroupBlock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GroupBlock.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/GroupBlock.tsx"],"names":[],"mappings":"AAcA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAUjE,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,EACzB,MAAM,EACN,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,KAAK,EACL,SAAS,EACT,IAAI,GACL,EAAE;IACD,MAAM,EAAE,oBAAoB,CAAC;IAC7B,KAAK,EAAE,WAAW,CAAC;IACnB,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,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC;IAC1C;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,+BAgGA;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,KAAK,EACL,SAAS,EACT,SAAS,GACV,EAAE;IACD,MAAM,EAAE,oBAAoB,CAAC;IAC7B,KAAK,EAAE,WAAW,CAAC;IACnB,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,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC;IAC1C;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,sCAkEA"}

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

@@ -0,0 +1,39 @@
+/** The group (or panel) an element is drawn in, never the element itself. */
+export declare function ownerOf(element: Element | null | undefined): Element | null;
+/**
+ * The condition at a path among an owner's own entries — the one a picker
+ * just added. Paths restart inside an element match's predicate, so only
+ * the owner's direct conditions are candidates.
+ */
+export declare function conditionAt(owner: Element | null, path: readonly number[]): HTMLElement | null;
+/** Whether the keyboard is nowhere: on the body, or on a control gone dead. */
+export declare function fell(): boolean;
+export interface ConditionFocus {
+    /**
+     * Said from the press that takes a condition or a group out: the entry
+     * holding `control` is going.
+     */
+    removing(control: Element): void;
+}
+export declare const ConditionFocusProvider: import('react').Provider<ConditionFocus>;
+export declare function useConditionFocus(): ConditionFocus;
+/**
+ * Where the keyboard stands after a condition or a group is taken out of
+ * the editor — the rule `useListFocus` keeps for the analysis cards,
+ * brought to the filter's strips.
+ *
+ * Pressing 「移除 X」 or 「移除分组」 with the keyboard removed the element
+ * the focus was on, and a focus with nothing under it falls to `<body>`: the
+ * next Tab started the page again, from the title bar (review R1-P1-1). A
+ * removal now leaves the keyboard where the entry was — the entry that took
+ * its place, the one before it if the strip ended there, and the group's
+ * own 「添加」 when nothing is left in it.
+ *
+ * The press only says what is going; the effect after the render that took
+ * it away places the focus, and only when the focus really fell — one that
+ * something else took meanwhile stays where it is. The holder must render
+ * after the press, which every removal causes: it is the panel, drawn from
+ * the tree the press changed.
+ */
+export declare function useConditionFocusRoot(): ConditionFocus;
+//# sourceMappingURL=conditionFocus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conditionFocus.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/conditionFocus.ts"],"names":[],"mappings":"AA6BA,6EAA6E;AAC7E,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,IAAI,CAE3E;AAqBD;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,OAAO,GAAG,IAAI,EACrB,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,WAAW,GAAG,IAAI,CAIpB;AAED,+EAA+E;AAC/E,wBAAgB,IAAI,IAAI,OAAO,CAQ9B;AAED,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CAClC;AAMD,eAAO,MAAM,sBAAsB,0CAAiC,CAAC;AAErE,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,IAAI,cAAc,CAiCtD"}

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

@@ -0,0 +1,20 @@
+import { KeyboardEvent } from 'react';
+/**
+ * Whether this is a press of Enter the filter editor may act on at all.
+ *
+ * Two presses are not, wherever in the editor they land, and they are not
+ * for reasons that have nothing to do with which control was focused:
+ *
+ * - one an IME is using to accept the characters being composed, which is
+ *   not a press of Enter at all as far as the user is concerned;
+ * - one held with a modifier, which is some other shortcut — very possibly
+ *   the host page's, and the host cannot get it back from a control that
+ *   swallowed it.
+ *
+ * `FilterPanel` asks this before its apply, and the number list's entry
+ * field asks it before its add, so the two answer a modified Enter the same
+ * way: by letting it through. It lives in its own file rather than beside
+ * either of them because both would otherwise import the other.
+ */
+export declare function isPlainEnter(event: KeyboardEvent<HTMLElement>): boolean;
+//# sourceMappingURL=enter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enter.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/enter.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,OAAO,CAIvE"}

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

@@ -0,0 +1,12 @@
+import { FilterGroupOperator } from '../../model/index.js';
+import { MessageKey } from '../kit/messages.js';
+/**
+ * What a group's operator says about the conditions under it.
+ *
+ * One mapping, because the select in a group's header, the menu that nests a
+ * new group and the summary above the result all name the same three things:
+ * a group that read "Any of" in one place and "Any condition" in another
+ * would read as two different settings.
+ */
+export declare const GROUP_OPERATOR_LABEL: Record<FilterGroupOperator, MessageKey>;
+//# sourceMappingURL=groupOperators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"groupOperators.d.ts","sourceRoot":"","sources":["../../../src/ui/filter/groupOperators.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,mBAAmB,EAAE,UAAU,CAIxE,CAAC"}

package/dist/ui/filter/inputs/calendar.d.ts

@@ -0,0 +1,26 @@
+import { ComponentProps } from 'react';
+import { Calendar } from '../../components/calendar.js';
+/**
+ * The registry's calendar, speaking the surface's language.
+ *
+ * `react-day-picker` reads its month names, its weekday heads and its ARIA
+ * labels out of a **date-fns `Locale` object**, and defaults to `en-US` when
+ * it is given none — so a `zh-CN` surface whose trigger said
+ * «2026年9月15日 – 2026年9月17日» opened a popover headed `September 2026` over
+ * `Su Mo Tu We Th Fr Sa`, with `Sunday, August 30th, 2026` and
+ * `Go to the Next Month` for a screen reader.
+ *
+ * A `ViewSurface`'s `locale` is a BCP-47 tag, not a date-fns locale, and
+ * there is no mapping from one to the other that does not mean bundling every
+ * locale the library ships. `Intl` needs no such table and no dependency: the
+ * library takes `formatters` and `labels` per string it draws, and every one
+ * of them is a date formatted in a language — which is the one thing
+ * `Intl.DateTimeFormat` does. The rest of this package already formats its
+ * dates that way (`ui/kit/display.ts`), so the picker and the cell beside it now
+ * name the same month in the same words.
+ *
+ * What is **not** covered: the month and year dropdowns' own names, which
+ * only exist under `captionLayout="dropdown"` and nothing here asks for.
+ */
+export declare const SurfaceCalendar: import('react').MemoExoticComponent<({ className, ...props }: ComponentProps<typeof Calendar>) => import('react').JSX.Element>;
+//# sourceMappingURL=calendar.d.ts.map

package/dist/ui/filter/inputs/calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/calendar.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAOxD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,eAAe,gEAGzB,cAAc,CAAC,OAAO,QAAQ,CAAC,iCAqBhC,CAAC"}

package/dist/ui/filter/inputs/candidates.d.ts

@@ -0,0 +1,27 @@
+import { FieldOption } from '../../../model/index.js';
+import { OptionSource } from '../../../runtime/index.js';
+export interface CandidateState {
+    /** `idle` until the first search is asked for; `failed` keeps the last page. */
+    status: 'idle' | 'loading' | 'success' | 'failed';
+    items: FieldOption[];
+    /** Where the next page starts, or `null` when this was the last. */
+    nextCursor: string | null;
+    /** True while a further page is on its way. */
+    loadingMore: boolean;
+}
+/**
+ * The candidates a `reference` editor offers, searched from its source.
+ *
+ * Nothing is asked until the list is opened, and a search is asked only once
+ * typing has paused: a pill on a saved view must not cost a request per
+ * render, and a source must not be asked once per keystroke. Every request
+ * carries an `AbortSignal`, and a query that changes under a request aborts
+ * it — the source is told, and its answer, if it still arrives, is dropped.
+ * A page that fails keeps what was already listed and says so, with a retry.
+ */
+export declare function useCandidates(source: OptionSource | null | undefined, query: string, active: boolean): {
+    state: CandidateState;
+    more(): void;
+    retry(): void;
+};
+//# sourceMappingURL=candidates.d.ts.map

package/dist/ui/filter/inputs/candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidates.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/candidates.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAK9D,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAClD,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,oEAAoE;IACpE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,+CAA+C;IAC/C,WAAW,EAAE,OAAO,CAAC;CACtB;AASD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,EACvC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,OAAO,GACd;IAAE,KAAK,EAAE,cAAc,CAAC;IAAC,IAAI,IAAI,IAAI,CAAC;IAAC,KAAK,IAAI,IAAI,CAAA;CAAE,CAqExD"}

package/dist/ui/filter/inputs/chips.d.ts

@@ -0,0 +1,56 @@
+import { FilterValue } from '../../../model/index.js';
+/**
+ * A list of typed values that grows, as chips on Base UI's `Combobox`.
+ *
+ * `IN` / `NOT_IN` take as many values as are entered, and this is the one
+ * control that collects them, for numbers and for text alike. It stands on
+ * the primitive's `multiple` mode with `Chips`: every value is a chip with a
+ * remove button named after it, Backspace in an empty entry takes the last
+ * one back, the arrow keys walk the chips, and what is typed is offered
+ * back as the one item of the popup — «Add 12» — so Enter, a click on it,
+ * and leaving the field all commit on the same terms. D16 before this it was
+ * a row of badges with a hand-written add button and no keyboard model.
+ *
+ * Three rules are this file's rather than the primitive's:
+ *
+ * - **Leaving the field commits.** Apply is a button elsewhere on the panel,
+ *   and reaching for it blurs the entry first; a value typed and not yet
+ *   added would be thrown away by the very click meant to run the query with
+ *   it. The primitive clears its input when the popup closes for any reason
+ *   but an item press, which would empty the field a moment before that
+ *   blur — so that clear is cancelled, and `onBlur` reads what is still
+ *   there.
+ * - **Nothing half-made is offered.** An empty entry, half a number, or a
+ *   value already in the list is not an item: the popup says why instead,
+ *   and Enter commits nothing. The same value twice asks nothing more of the
+ *   query and would name two remove buttons alike.
+ * - **What is being typed belongs to the list it is typed into.** A list
+ *   replaced from outside — the panel's discard, a config reload, another
+ *   view opened — is a different list, and a draft kept across that
+ *   replacement would be written back by the next blur: the discard would
+ *   not have discarded. The draft is therefore keyed on the list it was
+ *   typed over rather than synchronised in an effect.
+ */
+export declare function ValueChips<T extends string | number>({ value, values, onChange, label, disabled, invalid, parse, unparsable, inputMode, }: {
+    /** The list in force, as the host handed it over: the draft's key. */
+    value: FilterValue;
+    /** The same list, as the values this control shows. */
+    values: readonly T[];
+    onChange(values: T[]): void;
+    /** The list's own name; the entry and the popup are named after it. */
+    label: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    /** What the typed text is as a value, or `null` while it is not one yet. */
+    parse(text: string): T | null;
+    /** Why a non-empty entry is not a value, for the popup to say. */
+    unparsable: string;
+    /**
+     * Which keyboard a phone offers. `decimal` for a list of numbers — the
+     * digits and a separator, rather than the letters nothing here accepts —
+     * and the default for everything else, said out loud rather than left
+     * off: a list takes typing, and what it takes is part of the control.
+     */
+    inputMode?: 'decimal' | 'text';
+}): import('react').JSX.Element;
+//# sourceMappingURL=chips.d.ts.map

package/dist/ui/filter/inputs/chips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chips.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/chips.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAiB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,EACpD,KAAK,EACL,MAAM,EACN,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,KAAK,EACL,UAAU,EACV,SAAkB,GACnB,EAAE;IACD,sEAAsE;IACtE,KAAK,EAAE,WAAW,CAAC;IACnB,uDAAuD;IACvD,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC;IAC5B,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,4EAA4E;IAC5E,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC;IAC9B,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAChC,+BAwIA"}

package/dist/ui/filter/inputs/date.d.ts

@@ -0,0 +1,35 @@
+import { ValueProps } from './shared.js';
+/**
+ * A moment in time, said in one of three ways: off a calendar, as a window
+ * measured from now, or as a named period.
+ *
+ * The shape is chosen first, and each one has its own controls beside it.
+ * `date`, `dateRange` and `relativeDate` all arrive here — the kind's input
+ * decides whether the calendar picks one bound or two, not which shapes are
+ * on offer.
+ *
+ * A `required` value is never blanked from here: a board's starred date
+ * filter puts its default back the moment it is emptied, so 「指定日期」
+ * writing nothing-yet was undone before its calendar could be drawn, and the
+ * shape jumped back to 「时间段」. There the value in force stays until a
+ * date is picked, and the calendar waits beside it with nothing on it —
+ * and says so (`onAwaiting`), so what the value in force shows can say a
+ * date is to be picked rather than go on showing the old answer.
+ *
+ * `blank` words a value of nothing as a shape of its own, for a filter that
+ * may hold nothing: a board's optional date filter left unset narrows no
+ * panel, and its control says that — 「各面板自己的范围」 — rather than
+ * 「指定日期 · 选择日期 – 选择日期」 over panels reading last month.
+ *
+ * `oneDay` holds it to one day (`DashboardField.oneDay`): one calendar day,
+ * or one of the days by name that have come; no window, no longer period.
+ */
+export declare function DateValue({ value, onChange, label, disabled, invalid, range, withTime, required, oneDay, blank, onAwaiting, }: ValueProps & {
+    range: boolean;
+    withTime: boolean;
+    required?: boolean;
+    oneDay?: boolean;
+    blank?: string;
+    onAwaiting?: (awaiting: boolean) => void;
+}): import('react').JSX.Element;
+//# sourceMappingURL=date.d.ts.map

package/dist/ui/filter/inputs/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/date.tsx"],"names":[],"mappings":"AA2BA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAgB3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,KAAK,EACL,QAAQ,EACR,QAAgB,EAChB,MAAc,EACd,KAAK,EACL,UAAU,GACX,EAAE,UAAU,GAAG;IACd,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;CAC1C,+BAuHA"}

package/dist/ui/filter/inputs/daterange.d.ts

@@ -0,0 +1,28 @@
+import { FilterValue } from '../../../model/index.js';
+import { AbsoluteDateTimeValue } from '../../../filter/index.js';
+/**
+ * A day, or the two ends of a span of them, off a calendar — with the time
+ * of day beside it where the field carries one.
+ *
+ * One component for both because a range is the same calendar with a second
+ * bound: `dateRange` picks two, `date` picks one, and the trigger reads back
+ * whichever it has. The time of day belongs to the same control rather than
+ * to a second one: the calendar and the clock are two halves of one bound,
+ * and either of them writes the whole value once (D17-1).
+ */
+export declare function AbsoluteDate({ value, onChange, label, disabled, invalid, range, withTime, oneDay, }: {
+    value: AbsoluteDateTimeValue;
+    onChange(value: FilterValue): void;
+    label: string;
+    disabled?: boolean;
+    /** Whether the condition this date belongs to has been refused. */
+    invalid?: boolean;
+    range: boolean;
+    withTime: boolean;
+    /**
+     * One whole day, as a one-day filter holds it: the day picked is both
+     * ends (`DashboardField.oneDay`), never 「from this day on」.
+     */
+    oneDay?: boolean;
+}): import('react').JSX.Element;
+//# sourceMappingURL=daterange.d.ts.map

package/dist/ui/filter/inputs/daterange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daterange.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/daterange.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,0BAA0B,CAAC;AAUlC;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,KAAK,EACL,QAAQ,EACR,MAAc,GACf,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,+BAwIA"}

package/dist/ui/filter/inputs/duration.d.ts

@@ -0,0 +1,16 @@
+import { ValueProps } from './shared.js';
+/**
+ * A time since another moment (N3): 「距 [付款时间] [>] [48] [小时]」 — the
+ * earlier time among the fields beside this one, a comparison, an amount and
+ * a unit. Nothing is written until the earlier time is picked, which is what
+ * makes the condition a condition; after that each control changes its one
+ * part and keeps the rest.
+ */
+export declare function DurationValue({ value, onChange, label, disabled, invalid, times, }: ValueProps & {
+    /** The times the gap may run from: every other time field beside this one. */
+    times: readonly {
+        value: string;
+        label: string;
+    }[];
+}): import('react').JSX.Element;
+//# sourceMappingURL=duration.d.ts.map

package/dist/ui/filter/inputs/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/duration.tsx"],"names":[],"mappings":"AA4BA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,KAAK,GACN,EAAE,UAAU,GAAG;IACd,8EAA8E;IAC9E,KAAK,EAAE,SAAS;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACpD,+BAgEA"}

package/dist/ui/filter/inputs/number.d.ts

@@ -0,0 +1,47 @@
+import { ControlChromeProps } from '../../kit/variants.js';
+import { ValueProps } from './shared.js';
+/**
+ * A number field, on Base UI's `NumberField`.
+ *
+ * It used to be `<Input type="number">` with a draft record of its own, so
+ * that a half-typed number could stay half typed and an emptied field could
+ * say `null` rather than `Number('') === 0`. That is exactly the primitive's
+ * problem, solved: it keeps the text and the number apart, refuses characters
+ * that could never be part of a number, reports the parsed number as it is
+ * typed and `null` once the field is empty, formats on blur in the surface's
+ * locale, and carries the `inputmode`, `aria-roledescription` and arrow-key
+ * stepping a number field owes (D16) — the role description in the
+ * surface's words, where the primitive's own is English. The box itself is the vendored `Input`,
+ * rendered through the primitive so it looks like every other field here.
+ *
+ * Chromeless by default, because a condition pill is the field around it
+ * (D12). The analysis editor's row limit is the same control standing on
+ * its own, and asks for the registry's box with `chrome="box"`.
+ */
+export declare function NumberInput({ value, onNumber, label, disabled, invalid, chrome, className, placeholder, describedBy, id, required, }: ControlChromeProps & {
+    /** The number in force, if there is one. */
+    value: unknown;
+    /** Called only when the text parses; `null` once the field is empty. */
+    onNumber(value: number | null): void;
+    label: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    className?: string;
+    /**
+     * What an empty box stands for, where it stands for something: the row
+     * limit's blank is the N a view starts at, not a value still to be set.
+     */
+    placeholder?: string;
+    /** The id of the sentence that says why the box is refused. */
+    describedBy?: string;
+    /** The input's id, where a visible `FieldLabel` points at it. */
+    id?: string;
+    /** Said to a reader: the form cannot go without it. */
+    required?: boolean;
+}): import('react').JSX.Element;
+/** One number, the two ends of a range, or a list of as many as are wanted. */
+export declare function NumberValue({ value, onChange, label, disabled, invalid, range, multiple, control, }: ValueProps & {
+    range: boolean;
+    multiple: boolean;
+}): import('react').JSX.Element;
+//# sourceMappingURL=number.d.ts.map

package/dist/ui/filter/inputs/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/number.tsx"],"names":[],"mappings":"AAiBA,OAAO,EAAa,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3E,OAAO,EAAY,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAExD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,MAAM,EACN,SAAS,EACT,WAAW,EACX,WAAW,EACX,EAAE,EACF,QAAQ,GACT,EAAE,kBAAkB,GAAG;IACtB,4CAA4C;IAC5C,KAAK,EAAE,OAAO,CAAC;IACf,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,+BAiCA;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,KAAK,EACL,QAAQ,EACR,OAAO,GACR,EAAE,UAAU,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,+BAqCpD"}

package/dist/ui/filter/inputs/relative.d.ts

@@ -0,0 +1,23 @@
+import { FilterValue } from '../../../model/index.js';
+import { DateTimePreset, PresetDateTimeValue, RelativeDateTimeValue } from '../../../filter/index.js';
+/** A window measured from now: which way, how much, and of what. */
+export declare function RelativeDate({ value, onChange, label, disabled, invalid, }: {
+    value: RelativeDateTimeValue;
+    onChange(value: FilterValue): void;
+    label: string;
+    disabled?: boolean;
+    /** Whether the condition this window belongs to has been refused. */
+    invalid?: boolean;
+}): import('react').JSX.Element;
+/** A named period — today, this month — resolved against the engine's clock. */
+export declare function PresetDate({ value, presets, onChange, label, disabled, invalid, }: {
+    value: PresetDateTimeValue;
+    /** The periods offered; every one there is when left out. */
+    presets?: readonly DateTimePreset[];
+    onChange(value: FilterValue): void;
+    label: string;
+    disabled?: boolean;
+    /** Whether the condition this period belongs to has been refused. */
+    invalid?: boolean;
+}): import('react').JSX.Element;
+//# sourceMappingURL=relative.d.ts.map

package/dist/ui/filter/inputs/relative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relative.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/relative.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,mBAAmB,EAExB,KAAK,qBAAqB,EAE3B,MAAM,0BAA0B,CAAC;AAYlC,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,GACR,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qEAAqE;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,+BA8DA;AAED,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,OAA2B,EAC3B,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,GACR,EAAE;IACD,KAAK,EAAE,mBAAmB,CAAC;IAC3B,6DAA6D;IAC7D,OAAO,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qEAAqE;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,+BAmBA"}

package/dist/ui/filter/inputs/remote.d.ts

@@ -0,0 +1,20 @@
+import { FieldOption } from '../../../model/index.js';
+import { OptionSource } from '../../../runtime/index.js';
+import { ValueProps } from './shared.js';
+/**
+ * A value the host looks up rather than the kind declaring it.
+ *
+ * Three ways in, by what the host wired: the whole list at once (`options`),
+ * a searchable source (`source`, from `resolveOptions`), or neither — then
+ * the field is typed, since nothing is lost by typing an id that is already
+ * valid. The value keeps whatever shape it arrived in: a `reference` kind's
+ * `{ items: [{ id, label }] }`, where the label rides with the id so a saved
+ * view reopens without asking the source again, or a plain id list for a
+ * host kind that stores only ids.
+ */
+export declare function RemoteValue({ value, onChange, label, disabled, invalid, multiple, options, source, }: ValueProps & {
+    multiple: boolean;
+    options?: FieldOption[];
+    source?: OptionSource | null;
+}): import('react').JSX.Element;
+//# sourceMappingURL=remote.d.ts.map

package/dist/ui/filter/inputs/remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/remote.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAK3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAiB9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,OAAO,EACP,MAAM,GACP,EAAE,UAAU,GAAG;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CAC9B,+BAwBA"}

package/dist/ui/filter/inputs/select.d.ts

@@ -0,0 +1,26 @@
+import { FieldOption } from '../../../model/index.js';
+import { ValueProps } from './shared.js';
+/**
+ * Yes or no, and neither.
+ *
+ * A blank leaf used to show "False", so a row the user had only just added
+ * read as a condition already narrowing the list — and picking False, which
+ * is what it looked like they had, changed nothing and fired no event. It
+ * says `Not set` like every other blank value, rather than a word of its own.
+ */
+export declare function BooleanValue({ value, onChange, label, disabled, invalid, control, }: ValueProps): import('react').JSX.Element;
+/**
+ * Which records a soft-deleting source shows: the three readings of Wow's
+ * `DELETION` filter, worded by the catalogue. Blank is the source's own
+ * default, not deleted, which the applied bar says on its own (D17-2).
+ */
+export declare function DeletionValue({ value, onChange, label, disabled, invalid, }: ValueProps): import('react').JSX.Element;
+/**
+ * One or several of a declared list of options. The option's own value is
+ * what is stored: the control speaks in text, and the text is mapped back.
+ */
+export declare function OptionValue({ label, disabled, invalid, value, multiple, options, control, onChange, }: ValueProps & {
+    multiple: boolean;
+    options: readonly FieldOption[];
+}): import('react').JSX.Element;
+//# sourceMappingURL=select.d.ts.map

package/dist/ui/filter/inputs/select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../../../src/ui/filter/inputs/select.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAY3D,OAAO,EAA2B,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAEvE;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,EAC3B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,EACP,OAAO,GACR,EAAE,UAAU,+BAiBZ;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,OAAO,GACR,EAAE,UAAU,+BAgBZ;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,QAAQ,EACR,OAAO,EACP,KAAK,EACL,QAAQ,EACR,OAAO,EACP,OAAO,EACP,QAAQ,GACT,EAAE,UAAU,GAAG;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAA;CAAE,+BA2ErE"}