@persona/design-system 0.1.6 → 0.1.8

package/dist/FieldRegistry-rqSkjchY.d.mts

@@ -0,0 +1,122 @@
+import { a as FilterField, c as FilterOperator } from "./types-D58IoRx6.mjs";
+
+//#region components/DataTable/TableControls/FiltersV2/FieldRegistry.d.ts
+/**
+ * Per-resource field registry.
+ *
+ * Built from the backend's `field_key_to_info` payload (extended in v2 to
+ * include `type`, `options`, `item_type`, and a `source`/`parent_record_type`
+ * pair for custom fields). The registry is the single place the UI looks up
+ * "what field is this and what can the user do with it" — value control
+ * rendering, operator vocabulary, picker grouping, and popover footer text
+ * all route through here.
+ *
+ * Construction is tolerant of partial metadata: if `type` is missing the
+ * field falls back to `'string'`.
+ */
+declare class FieldRegistry<TField extends FilterField = FilterField> {
+  readonly resource: string;
+  private readonly byId;
+  /** Custom fields grouped by parent record type label, used by the picker submenu. */
+  private readonly customByParent;
+  /** Parent record id → its display label, used to resolve selector pills to picker groups. */
+  private readonly parentLabelByRecordId;
+  private readonly systemFields;
+  private readonly narrowingSelectors;
+  constructor(resource: string, fields: ReadonlyArray<TField>);
+  parentRecordLabelForId(recordId: string): string | undefined;
+  has(fieldId: string): boolean;
+  get(fieldId: string): TField | undefined;
+  /**
+   * Get a field by id, throwing if it isn't registered. Use this when the
+   * fieldId came from state we own (e.g. an existing `FilterRule`) and a
+   * missing field is a programming error rather than user input.
+   */
+  getOrThrow(fieldId: string): TField;
+  /** All registered fields, in insertion order. */
+  all(): ReadonlyArray<TField>;
+  /** System / built-in fields, used as the top section of the `⊕ Filter` menu. */
+  systemFieldsList(): ReadonlyArray<TField>;
+  /** Custom fields grouped by parent record type for the picker submenu. */
+  customFieldGroups(): ReadonlyArray<{
+    parent: string;
+    fields: ReadonlyArray<TField>;
+  }>;
+  /**
+   * Fields that drive the picker's field-narrowing. A field is inferred
+   * as a scoping selector (e.g. `account_type`, `case_template`) when its
+   * `options[].value` set intersects the registry's custom-field
+   * `parentRecordId`s — matching on the backend id, not the display label,
+   * so a suffixed or colliding label (`"KYC Standard (CAS)"`) still
+   * narrows correctly. `FilterBar` turns an active `is` pill on such a
+   * field into the visible parent labels via {@link parentRecordLabelForId}.
+   *
+   * A coincidental id collision would falsely tag a field as a selector —
+   * benign (it just narrows too); layer on a backend flag if ever needed.
+   */
+  narrowingSelectorFields(): ReadonlyArray<TField>;
+  /** Operator vocabulary for a registered field, gated by its `allowedOperators` then type. */
+  operatorsFor(fieldId: string): ReadonlyArray<FilterOperator>;
+  /** Default operator for a registered field. Used when creating a new pill. */
+  defaultOperatorFor(fieldId: string): FilterOperator;
+  /**
+   * Pick the operator to use for a rule after a field swap. If the
+   * previous operator is still in the new field's vocabulary, keep it
+   * (the user's intent likely carries over — e.g. `is_empty` stays
+   * `is_empty` regardless of field type). Otherwise fall back to the
+   * field's default operator.
+   *
+   * Lives on the registry rather than as a free helper because the
+   * answer is entirely a function of registry-owned data (operator
+   * vocabulary per type) — and centralizing it keeps the field-swap
+   * semantics consistent across `FilterBar.handlePickField`,
+   * `AdvancedFilterRulesPopover.handleFieldChange`, and any future
+   * caller.
+   */
+  reconcileOperator(fieldId: string, prevOperator: FilterOperator): FilterOperator;
+  /**
+   * Build a `value → label` lookup for a `choices` / `multi_choices`
+   * field, suitable for translating raw option ids into the human
+   * labels rendered by `FilterPill` chips and value-control headers.
+   * Returns `undefined` when the field has no options so callers can
+   * skip the lookup entirely.
+   *
+   * Memoized per-field so repeated reads from render loops don't
+   * rebuild the same map. Field options are immutable for the lifetime
+   * of a `FieldRegistry`, so the cache never needs invalidation.
+   */
+  optionLabelsFor(fieldId: string): Record<string, string> | undefined;
+  private readonly optionLabelCache;
+}
+/**
+ * Backend metadata for one field as exposed by the v2 `field_key_to_info`
+ * payload. All fields except `label` are optional — v1 responses only carry
+ * `label`/`tokens`. The registry tolerates the missing fields and falls back
+ * to safe defaults.
+ */
+interface RawFieldInfo {
+  label: string;
+  tokens?: ReadonlyArray<string>;
+  /** v2 metadata — present once the backend ships its extended schema. */
+  type?: string;
+  source?: string;
+  parent_record_type?: string;
+  parent_record_id?: string;
+  options?: ReadonlyArray<{
+    label: string;
+    value: string;
+  }>;
+  item_type?: string;
+  path?: ReadonlyArray<string>;
+}
+/**
+ * Build a registry from a `field_key_to_info` map. Forgiving by design — any
+ * key whose `type` is missing or unrecognized falls back to `'string'`, and
+ * `source` defaults to `'custom'` (current `customFilters` are all custom).
+ */
+declare function buildFieldRegistry(resource: string, fieldKeyToInfo: Record<string, RawFieldInfo>, options?: {
+  systemFields?: ReadonlyArray<FilterField>;
+}): FieldRegistry;
+//#endregion
+export { RawFieldInfo as n, buildFieldRegistry as r, FieldRegistry as t };
+//# sourceMappingURL=FieldRegistry-rqSkjchY.d.mts.map

package/dist/FieldRegistry.d.cts

@@ -0,0 +1,2 @@
+import { n as RawFieldInfo, r as buildFieldRegistry, t as FieldRegistry } from "./FieldRegistry-OX60T3hr.cjs";
+export { FieldRegistry, RawFieldInfo, buildFieldRegistry };

package/dist/FieldRegistry.d.mts

@@ -0,0 +1,2 @@
+import { n as RawFieldInfo, r as buildFieldRegistry, t as FieldRegistry } from "./FieldRegistry-rqSkjchY.mjs";
+export { FieldRegistry, RawFieldInfo, buildFieldRegistry };

package/dist/FilterBar-D3LiIy1-.d.mts

@@ -0,0 +1,103 @@
+import { d as FilterSize, f as FilterStateV2 } from "./types-D58IoRx6.mjs";
+import { t as FieldRegistry } from "./FieldRegistry-rqSkjchY.mjs";
+import { n as ValueControlResolver } from "./value-control-resolver-CE-bqdAl.mjs";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region components/DataTable/TableControls/FiltersV2/FilterBar/FilterBar.d.ts
+/**
+ * Filter UI v2 — the top-level FilterBar component.
+ *
+ * Composes the picker, simple-rule pills, simple-rule popovers, Rules pill,
+ * Advanced Filter Rules popover, and type-aware value controls into one bar.
+ *
+ * Popover open/close transitions flow through Radix's `onOpenChange`
+ * callbacks rather than explicit `onClick` handlers on the pills. That keeps
+ * the user's pill click and Radix's `Slot`-injected toggle handler from
+ * fighting over which one wins (the symptom looks like "the popover opens
+ * and immediately closes" — both fire, the first sets open=true, the second
+ * toggles open back to false).
+ */
+interface FilterBarProps {
+  /**
+   * Registry built from this resource's `field_key_to_info` response.
+   * The registry defines which fields are filterable, each field's type,
+   * option labels, and custom-field parent grouping.
+   */
+  registry: FieldRegistry;
+  /**
+   * Initial state. Defaults to the empty state. For URL/saved-view
+   * hydration, pass the decoded `FilterStateV2` here.
+   *
+   * Re-read when it changes. This lets saved-view and URL hydration swap
+   * the whole filter state after mount without requiring the caller to
+   * remount the bar.
+   *
+   * A pill without a value isn't part of this state and survives hydration —
+   * it is the bar's while it has none, and only its field leaving the registry
+   * drops it.
+   */
+  initialState?: FilterStateV2;
+  /**
+   * Called whenever the structured filter state changes.
+   *
+   * Kept as a single-arg callback so the most common consumer — a
+   * `setState`-style parent driving the bar as a controlled component
+   * (`<FilterBar initialState={state} onChange={setState} />`) — can
+   * pass `setState` directly.
+   *
+   * Reports only valued filters, so feeding the reported state straight
+   * back as `initialState` is a no-op.
+   */
+  onChange?: (state: FilterStateV2) => void;
+  /**
+   * Whether this bar should show the Rules pill + Advanced Filter Rules
+   * popover. When `false`, compound state is pinned to empty.
+   *
+   * @defaultValue `true`
+   */
+  advancedRulesEnabled?: boolean;
+  /**
+   * Keeps the Add-filter picker from building a second top-level pill on a
+   * field that already has one: a field in use drops out of the picker, and
+   * the trigger disappears once no field is left. Compound rules are
+   * unaffected — a field can back a pill and any number of Advanced Filter
+   * Rules at once. Leave off for hosts whose serializer reads repeated rules
+   * on one field as a conjunction (e.g. two date bounds spanning a range).
+   *
+   * Rules arriving through `initialState` are rendered as given; a saved view
+   * holding duplicates keeps them rather than having pills silently dropped
+   * out from under it, so a host that stored duplicates before enabling this
+   * can migrate them on its own terms.
+   *
+   * @defaultValue `false`
+   */
+  singleUseFields?: boolean;
+  /**
+   * Size variant for every Filter UI v2 subcomponent. `'md'` is the
+   * standard-DataTable default (14px font, 16px icons, 32px-tall
+   * controls). `'sm'` is the compact-DataTable variant (12px font,
+   * 12px icons, 24px-tall controls). Propagated to subcomponents via
+   * `FilterBarContext` so each one reads the active size without
+   * the caller having to pass it through every level.
+   *
+   * @defaultValue `'md'`
+   */
+  size?: FilterSize;
+  /**
+   * Renders host-specific field types before falling back to PDS controls.
+   * Return a nullish value to use the built-in resolver.
+   */
+  valueControlResolver?: ValueControlResolver;
+}
+declare function FilterBar({
+  registry,
+  initialState,
+  onChange,
+  advancedRulesEnabled,
+  singleUseFields,
+  size,
+  valueControlResolver
+}: FilterBarProps): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { FilterBarProps as n, FilterBar as t };
+//# sourceMappingURL=FilterBar-D3LiIy1-.d.mts.map

package/dist/FilterBar-YzOh02f9.d.cts

@@ -0,0 +1,103 @@
+import { d as FilterSize, f as FilterStateV2 } from "./types-B_HHNlia.cjs";
+import { t as FieldRegistry } from "./FieldRegistry-OX60T3hr.cjs";
+import { n as ValueControlResolver } from "./value-control-resolver-B9p25q3G.cjs";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime.js";
+
+//#region components/DataTable/TableControls/FiltersV2/FilterBar/FilterBar.d.ts
+/**
+ * Filter UI v2 — the top-level FilterBar component.
+ *
+ * Composes the picker, simple-rule pills, simple-rule popovers, Rules pill,
+ * Advanced Filter Rules popover, and type-aware value controls into one bar.
+ *
+ * Popover open/close transitions flow through Radix's `onOpenChange`
+ * callbacks rather than explicit `onClick` handlers on the pills. That keeps
+ * the user's pill click and Radix's `Slot`-injected toggle handler from
+ * fighting over which one wins (the symptom looks like "the popover opens
+ * and immediately closes" — both fire, the first sets open=true, the second
+ * toggles open back to false).
+ */
+interface FilterBarProps {
+  /**
+   * Registry built from this resource's `field_key_to_info` response.
+   * The registry defines which fields are filterable, each field's type,
+   * option labels, and custom-field parent grouping.
+   */
+  registry: FieldRegistry;
+  /**
+   * Initial state. Defaults to the empty state. For URL/saved-view
+   * hydration, pass the decoded `FilterStateV2` here.
+   *
+   * Re-read when it changes. This lets saved-view and URL hydration swap
+   * the whole filter state after mount without requiring the caller to
+   * remount the bar.
+   *
+   * A pill without a value isn't part of this state and survives hydration —
+   * it is the bar's while it has none, and only its field leaving the registry
+   * drops it.
+   */
+  initialState?: FilterStateV2;
+  /**
+   * Called whenever the structured filter state changes.
+   *
+   * Kept as a single-arg callback so the most common consumer — a
+   * `setState`-style parent driving the bar as a controlled component
+   * (`<FilterBar initialState={state} onChange={setState} />`) — can
+   * pass `setState` directly.
+   *
+   * Reports only valued filters, so feeding the reported state straight
+   * back as `initialState` is a no-op.
+   */
+  onChange?: (state: FilterStateV2) => void;
+  /**
+   * Whether this bar should show the Rules pill + Advanced Filter Rules
+   * popover. When `false`, compound state is pinned to empty.
+   *
+   * @defaultValue `true`
+   */
+  advancedRulesEnabled?: boolean;
+  /**
+   * Keeps the Add-filter picker from building a second top-level pill on a
+   * field that already has one: a field in use drops out of the picker, and
+   * the trigger disappears once no field is left. Compound rules are
+   * unaffected — a field can back a pill and any number of Advanced Filter
+   * Rules at once. Leave off for hosts whose serializer reads repeated rules
+   * on one field as a conjunction (e.g. two date bounds spanning a range).
+   *
+   * Rules arriving through `initialState` are rendered as given; a saved view
+   * holding duplicates keeps them rather than having pills silently dropped
+   * out from under it, so a host that stored duplicates before enabling this
+   * can migrate them on its own terms.
+   *
+   * @defaultValue `false`
+   */
+  singleUseFields?: boolean;
+  /**
+   * Size variant for every Filter UI v2 subcomponent. `'md'` is the
+   * standard-DataTable default (14px font, 16px icons, 32px-tall
+   * controls). `'sm'` is the compact-DataTable variant (12px font,
+   * 12px icons, 24px-tall controls). Propagated to subcomponents via
+   * `FilterBarContext` so each one reads the active size without
+   * the caller having to pass it through every level.
+   *
+   * @defaultValue `'md'`
+   */
+  size?: FilterSize;
+  /**
+   * Renders host-specific field types before falling back to PDS controls.
+   * Return a nullish value to use the built-in resolver.
+   */
+  valueControlResolver?: ValueControlResolver;
+}
+declare function FilterBar({
+  registry,
+  initialState,
+  onChange,
+  advancedRulesEnabled,
+  singleUseFields,
+  size,
+  valueControlResolver
+}: FilterBarProps): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { FilterBarProps as n, FilterBar as t };
+//# sourceMappingURL=FilterBar-YzOh02f9.d.cts.map

package/dist/FilterBar.d.cts

@@ -0,0 +1,2 @@
+import { n as FilterBarProps, t as FilterBar } from "./FilterBar-YzOh02f9.cjs";
+export { FilterBarProps, FilterBar as default };

package/dist/FilterBar.d.mts

@@ -0,0 +1,2 @@
+import { n as FilterBarProps, t as FilterBar } from "./FilterBar-D3LiIy1-.mjs";
+export { FilterBarProps, FilterBar as default };

package/dist/FilterPickerMenu.d.mts

@@ -0,0 +1,84 @@
+import { a as FilterField, d as FilterSize } from "./types-D58IoRx6.mjs";
+import { t as FieldRegistry } from "./FieldRegistry-rqSkjchY.mjs";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+import { HTMLAttributes } from "react";
+
+//#region components/DataTable/TableControls/FiltersV2/FilterPickerMenu/FilterPickerMenu.d.ts
+/**
+ * Props for `FilterPickerMenu` — the `⊕ Filter` cascading picker.
+ *
+ * The picker surfaces a `FilterField` selection back to the parent
+ * (TableControls/FiltersV2) via `onPickField`. The parent owns the subsequent
+ * FilterPopover that lets the user pick an operator and value.
+ *
+ * Internally this is a thin wrapper around the design-system Combobox's
+ * `trigger` prop: the `⊕ Filter` button (or compact `⊕` icon button) is
+ * passed as the trigger, and the Combobox renders the search input
+ * + nested-navigation dropdown content directly beneath it. System
+ * fields live at the root; every custom field sits behind a single
+ * "Fields" submenu with its parent record type as a sublabel. Typing
+ * flattens the whole tree and surfaces every matching leaf with a
+ * breadcrumb in its description.
+ */
+interface FilterPickerMenuProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+  /** Registry exposing the resource's system + custom fields. */
+  registry: FieldRegistry;
+  /**
+   * Called when the user picks a field. The parent is responsible for
+   * opening the value-control popover for the picked field.
+   */
+  onPickField: (field: FilterField) => void;
+  /**
+   * Override for the default `Filter` trigger button label.
+   *
+   * @defaultValue `'Filter'`
+   */
+  triggerLabel?: string;
+  /**
+   * When true, the trigger renders icon-only (the `⊕` prefix icon
+   * without the visible label). The `triggerLabel` is still used as
+   * the button's `aria-label` for accessibility. Used once the bar
+   * already has pills.
+   */
+  compact?: boolean;
+  /** Disables the trigger button (e.g. while the registry is loading). */
+  disabled?: boolean;
+  /**
+   * Allow-list of `parentRecordType` labels that should appear in the
+   * "Fields" submenu. When omitted (or `undefined`), every custom-field
+   * group is shown — the default behavior.
+   *
+   * The picker is intentionally policy-free here — it just applies the
+   * filter. The parent (`FilterBar`) derives this list from the active
+   * rules on `registry.recordTypeSelectorFields()` and passes it
+   * through. Passing an empty array hides the Fields submenu entirely
+   * (no parents match, so no custom fields render).
+   */
+  visibleCustomFieldParents?: ReadonlyArray<string>;
+  /**
+   * Deny-list of field ids to omit from the menu. When it covers every
+   * selectable field the trigger is not rendered at all.
+   */
+  excludeFieldIds?: ReadonlyArray<string>;
+  /**
+   * Size variant. Defaults to whatever the surrounding
+   * `FilterBarContext` provides (`'sm'` outside a FilterBar).
+   * Threaded into the Combobox and the trigger Button/IconButton so the
+   * picker matches the surrounding pills.
+   */
+  size?: FilterSize;
+}
+declare const FilterPickerMenu: ({
+  registry,
+  onPickField,
+  triggerLabel,
+  compact,
+  disabled,
+  visibleCustomFieldParents,
+  excludeFieldIds,
+  size,
+  ...rest
+}: FilterPickerMenuProps) => _$react_jsx_runtime0.JSX.Element | null;
+//#endregion
+export { FilterPickerMenuProps, FilterPickerMenu as default };
+//# sourceMappingURL=FilterPickerMenu.d.mts.map

package/dist/FilterPill.d.mts

@@ -0,0 +1,60 @@
+import { a as FilterField, d as FilterSize, l as FilterRule } from "./types-D58IoRx6.mjs";
+import * as _$react from "react";
+import { HTMLAttributes } from "react";
+
+//#region components/DataTable/TableControls/FiltersV2/FilterPill/FilterPill.d.ts
+/**
+ * Props for `FilterPill` — one entry in `FilterStateV2.topLevelRules`
+ * rendered as an interactive pill.
+ *
+ * The container chrome (rounded 24px pill, variant background, focus
+ * ring, caret↔dismiss swap) is provided by `PillShell`. This file
+ * owns the pill's filter-specific body content: field label, operator
+ * label, and value chip(s).
+ */
+interface FilterPillProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'onClick'> {
+  /** Field metadata, used for the label and value-chip lookups. */
+  field: FilterField;
+  /** Active rule, or `null` for the default/unset state. */
+  rule: FilterRule | null;
+  /**
+   * User clicked the pill body — parent should open the value-edit popover.
+   *
+   * Optional because the most common usage is as a Radix `Popover.Trigger`
+   * `asChild` element. In that case Radix's `Slot` injects its own click
+   * handler on the outer `<span>` that toggles the popover; clicks bubble
+   * from the inner body button up to the span and fire it. The dismiss
+   * button's `stopPropagation` (inside `PillShell`) keeps ✕ clicks from
+   * triggering the popover.
+   */
+  onClick?: () => void;
+  /** User clicked the ✕ — parent should remove the rule. */
+  onDismiss: () => void;
+  /**
+   * Visual variant.
+   *
+   * - `'default'` (default) — neutral gray pill, shows `▾`.
+   * - `'active'` — purple pill used when the popover is open. Always
+   *   shows `×` (in place of the caret).
+   *
+   * On hover, the default variant also swaps `▾` for `×`.
+   */
+  variant?: 'default' | 'active';
+  /**
+   * Optional label-lookup map for `choices` / `multi_choices` fields. When
+   * provided, raw option values in the rule are translated to their
+   * human-readable labels before rendering. Falls through to the raw value
+   * when the map is missing or doesn't contain the option.
+   */
+  optionLabels?: Record<string, string>;
+  /**
+   * Size variant. Forwarded to `PillShell` and to the value-chip
+   * styling. Defaults to whatever the surrounding `FilterBarContext`
+   * provides (`'sm'` outside a `FilterBar`).
+   */
+  size?: FilterSize;
+}
+declare const FilterPill: _$react.ForwardRefExoticComponent<FilterPillProps & _$react.RefAttributes<HTMLSpanElement>>;
+//#endregion
+export { FilterPillProps, FilterPill as default };
+//# sourceMappingURL=FilterPill.d.mts.map

package/dist/FilterPopover.d.mts

@@ -0,0 +1,87 @@
+import { a as FilterField, c as FilterOperator, d as FilterSize } from "./types-D58IoRx6.mjs";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
+
+//#region components/DataTable/TableControls/FiltersV2/FilterPopover/FilterPopover.d.ts
+/**
+ * Props for `FilterPopover` — the single-rule editor that opens from a
+ * `FilterPill` body click or from the `FilterPickerMenu` after a field
+ * is picked.
+ *
+ *   ┌──────────────────────────────────┐
+ *   │ Field name   is ▾                │  ← inline header (12px secondary + operator)
+ *   │ ┌────────────────────────────┐   │
+ *   │ │ value control (parent slot)│   │
+ *   │ └────────────────────────────┘   │
+ *   ├──────────────────────────────────┤
+ *   │ ⓘ Field name is a field on …    │  ← footer (10px secondary, custom fields only)
+ *   └──────────────────────────────────┘
+ *
+ * The value control slot is whatever the parent passes
+ * — text input, multi-select, calendar, etc.
+ */
+interface FilterPopoverProps {
+  /** Field metadata, used for the header label, operator vocabulary, and footer. */
+  field: FilterField;
+  /** Currently selected operator for this rule. */
+  operator: FilterOperator;
+  /** Called when the user picks a new operator from the dropdown. */
+  onChangeOperator: (op: FilterOperator) => void;
+  /**
+   * The parent-supplied value control. This component is intentionally
+   * agnostic about the inner UI — the per-type value controls (text input,
+   * multi-select, calendar, etc.) live outside this file and are wired in
+   * by the parent via this slot.
+   */
+  valueControlSlot: ReactNode;
+  /** Called when the popover should close (e.g. Escape, click-outside). */
+  onClose: () => void;
+  /** Anchor element — passed through to Radix `Popover.Trigger` as a child. */
+  trigger: ReactNode;
+  /**
+   * Controlled-open flag. Same pass-through convention as `FilterPickerMenu`:
+   * when both `open` and `onOpenChange` are provided the popover behaves as a
+   * fully controlled component; otherwise Radix manages open state internally.
+   */
+  open?: boolean;
+  /**
+   * Controlled-open setter, called by Radix whenever it wants to transition
+   * the popover's open state. The parent is free to ignore this and force a
+   * different state if it needs to (e.g. block-close while editing).
+   */
+  onOpenChange?: (open: boolean) => void;
+  /**
+   * Size variant. Defaults to whatever the surrounding
+   * `FilterBarContext` provides (`'sm'` outside a FilterBar).
+   * Drives header/operator font + glyph sizes plus the `size` prop
+   * passed to any DropdownMenu items.
+   */
+  size?: FilterSize;
+}
+/**
+ * The single-rule editor popover. Renders a Radix `Popover` anchored on
+ * `trigger`, with a `Popover.Card` body that stacks:
+ *
+ *   1. Inline header — "[Field name]  [operator ▾]" on one line.
+ *   2. Parent-supplied value control.
+ *   3. Custom-field footer (`ⓘ [label] is a field on [parentRecordType]`).
+ *
+ * The popover stays purely presentational. Rule state lives in the parent's
+ * `useFilterStateV2()` hook; this component just routes operator changes
+ * back through `onChangeOperator` and forwards open/close transitions
+ * through Radix's controlled props.
+ */
+declare const FilterPopover: ({
+  field,
+  operator,
+  onChangeOperator,
+  valueControlSlot,
+  onClose,
+  trigger,
+  open,
+  onOpenChange,
+  size
+}: FilterPopoverProps) => _$react_jsx_runtime0.JSX.Element;
+//#endregion
+export { FilterPopoverProps, FilterPopover as default };
+//# sourceMappingURL=FilterPopover.d.mts.map

package/dist/FloatValueControl.d.mts

@@ -0,0 +1,40 @@
+import { t as ValueControlProps } from "./types-D7ppqnNj.mjs";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region components/DataTable/TableControls/FiltersV2/value-controls/FloatValueControl/FloatValueControl.d.ts
+type FloatValueControlProps = ValueControlProps;
+/**
+ * Float-typed value control for the Filter UI v2 popover.
+ *
+ * Used for `float` fields with operators `is` / `is_not`. The popover
+ * renders nothing when the operator is valueless (`is_empty` /
+ * `is_not_empty`). Range operators are not part of the current numeric
+ * field vocabulary.
+ *
+ * The control accepts decimal input and emits a `number` via `onChange`.
+ * We keep local display state as a string so partial input like `"3."` is
+ * preserved while the user types; the emitted numeric value is only updated
+ * once the input parses to a finite number.
+ *
+ * `isFocused` ref guards the external-value sync effect: typing a
+ * mid-decimal value like `"3."` parses to `3` and emits it, which
+ * round-trips back through the controlled `value` prop. Without the
+ * guard, the sync effect would rewrite the display from `"3."` to
+ * `"3"` and the next keystroke (`"7"`) would land at the wrong cursor
+ * position. The blur handler resyncs the display so any half-typed
+ * string that never parsed (`"-"`, `"."`) renders as whatever the
+ * rule actually carries when focus leaves.
+ *
+ * `onChange` is debounced (300ms) to avoid committing on every keystroke;
+ * the debounce flushes on blur and on unmount so no pending value is lost.
+ */
+declare const FloatValueControl: ({
+  field,
+  operator,
+  value,
+  onChange,
+  ariaLabel
+}: FloatValueControlProps) => _$react_jsx_runtime0.JSX.Element | null;
+//#endregion
+export { FloatValueControl, FloatValueControl as default, FloatValueControlProps };
+//# sourceMappingURL=FloatValueControl.d.mts.map

package/dist/{FormControl-fK4HA_yF.mjs → FormControl-B28qa7aQ.mjs}

@@ -1,12 +1,12 @@
-import { a as Tooltip, n as TextWithDashedUnderline } from "./Tooltip-CDvOu1UN.mjs";
-import { n as useFormGroup } from "./useFormGroup-z0epBxXn.mjs";
-import { n as useFormField, t as FormControlContext } from "./useFormField-D0RTrPld.mjs";
+import { a as Tooltip, n as TextWithDashedUnderline } from "./Tooltip-C6AR1xT-.mjs";
+import { n as useFormGroup } from "./useFormGroup-DWVW7A9f.mjs";
+import { n as useFormField, t as FormControlContext } from "./useFormField-DhYd6bNn.mjs";
 import { Color, Spacing, Typography } from "@persona/design-tokens";
 import styled, { css } from "styled-components";
-import { Children, forwardRef, isValidElement, useMemo } from "react";
 import { jsx } from "react/jsx-runtime";
-import { Root } from "@radix-ui/react-label";
+import { Children, forwardRef, isValidElement, useMemo } from "react";
 import uniqueId from "lodash/fp/uniqueId.js";
+import { Root } from "@radix-ui/react-label";
 //#region components/FormControl/FormControl.tsx
 const LabelBase = styled(Root)`
   ${({ $size }) => {
@@ -165,4 +165,4 @@ const FormControl = forwardRef(function FormControl({ children, hasError, hasWar
 //#endregion
 export { FormLabel as a, FormInputContainer as i, ErrorText as n, HelperText as o, FormControl as r, WarningText as s, Container as t };
 
-//# sourceMappingURL=FormControl-fK4HA_yF.mjs.map
+//# sourceMappingURL=FormControl-B28qa7aQ.mjs.map