@servicetitan/anvil2 3.0.6 → 3.0.8

package/dist/src/beta/components/FilterBar/FilterPopoverButton.d.ts

@@ -0,0 +1,86 @@
+import { ReactNode } from 'react';
+import { Filter } from './internal/types';
+/**
+ * Render-prop ctx passed to FilterPopoverButton's children. The `custom`
+ * adapter (and any consumer using a `custom` filter) uses this to receive the
+ * draft (or committed) value and an `onChange` for its rendered body.
+ *
+ * When commitOnSelect is false (the default), `value` is the in-progress draft
+ * and `onChange` updates it; the user must click Apply for it to commit.
+ *
+ * When commitOnSelect is true, `value` is the filter's currently-committed
+ * value and `onChange` commits immediately (and closes the popover).
+ */
+export type FilterPopoverButtonRenderCtx<V = unknown> = {
+    value: V;
+    onChange: (value: V) => void;
+};
+/**
+ * Base props shared by both commit modes. `commitOnSelect` is left out so each
+ * variant can refine it as a literal; that's what lets `initialValue` be required
+ * for the draft branch and absent for the commit-on-select branch.
+ */
+type FilterPopoverButtonBaseProps<V> = {
+    /** The filter being edited. Used for id and dispatching commits. */
+    filter: Filter;
+    /** Trigger button label. Adapters typically pass adapter.formatLabel(filter). */
+    label: ReactNode;
+    /** Whether the filter currently has a non-default value (drives selected styling). */
+    isSelected: boolean;
+    /**
+     * The filter's currently-committed value. Used to seed the draft on open and
+     * to detect parent-provided changes mid-open. Adapters typically pass
+     * adapter.getValue(filter).
+     */
+    committedValue: V;
+    /** Body content as a render-prop. Receives draft (or live) value + onChange. */
+    children: (ctx: FilterPopoverButtonRenderCtx<V>) => ReactNode;
+};
+/**
+ * Draft-mode props: requires `initialValue` so each consumer declares what
+ * "empty draft" means for its V (e.g. an array-shaped custom filter passes
+ * `[]`, a nullable scalar passes `null`). Eliminates the `[] as unknown as V`
+ * cast and forces non-nullable V consumers to opt in explicitly.
+ */
+type DraftModeProps<V> = FilterPopoverButtonBaseProps<V> & {
+    commitOnSelect?: false;
+    /**
+     * Initial draft value used until the popover opens and the draft is seeded
+     * from `committedValue`. Each adapter owns the empty-state for its V.
+     */
+    initialValue: V;
+    /**
+     * If true, in uncontrolled mode the popover stays open after a body change
+     * instead of closing — for multi-selection workflows.
+     * @default false
+     */
+    keepOpenOnUncontrolledChange?: boolean;
+};
+/**
+ * Commit-on-select props: no draft state exists, so `initialValue` and
+ * `keepOpenOnUncontrolledChange` don't apply.
+ */
+type CommitOnSelectProps<V> = FilterPopoverButtonBaseProps<V> & {
+    commitOnSelect: true;
+};
+type FilterPopoverButtonProps<V> = DraftModeProps<V> | CommitOnSelectProps<V>;
+/**
+ * FilterPopoverButton is the popover-based trigger primitive used by the
+ * `custom` filter adapter (and anything else that needs to render an
+ * adapter-agnostic popover body with draft / Apply-Cancel semantics).
+ *
+ * Other filter types (`singleSelect`, `multiSelect`, `asyncSelect`,
+ * `asyncMultiSelect`, `date`, `dateRange`, `dateList`) compose menu primitives
+ * (`SelectMenu`, `MultiSelectMenu`) or their own popover shells directly and
+ * do not go through this component.
+ *
+ * It owns:
+ * - The trigger button (label + icon + selected state)
+ * - The OptionsPopover wrapper (open state, outside-press handling)
+ * - When commitOnSelect is false: draft state + MenuFooter Apply/Cancel chrome
+ *
+ * The body is supplied via render-prop children, which receive the
+ * appropriate value + onChange for the current commit mode.
+ */
+export declare const FilterPopoverButton: <V>(props: FilterPopoverButtonProps<V>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/beta/components/FilterBar/FilterTextInput.d.ts

@@ -0,0 +1,29 @@
+import { TextInputFilter } from './internal/types';
+/**
+ * Props for the FilterTextInput component.
+ */
+interface FilterTextInputProps {
+    /** The text input filter — drives label, placeholder, and max length. */
+    filter: TextInputFilter;
+    /** Current text value. */
+    value: string;
+    /** Callback to update the value. Receives the truncated string. */
+    onChange: (value: string) => void;
+    /**
+     * `compact` hides the field's own label (toolbar popover — the filter
+     * button doubles as the label); `grid` shows it (drawer cell).
+     */
+    layout: "compact" | "grid";
+}
+/**
+ * Single-line TextField for the textInput filter. Used as the popover body in
+ * the toolbar (`layout="compact"`) and as the cell in the drawer
+ * (`layout="grid"`).
+ *
+ * Features:
+ * - Truncates entered text to `filter.maxLength` before emitting
+ * - Optional `current/max` character counter (`showCounter`)
+ * - Hides its own label in `compact` (the filter button doubles as the label)
+ */
+export declare const FilterTextInput: ({ filter, value, onChange, layout, }: FilterTextInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/beta/components/FilterBar/FilterToggleButton.d.ts

@@ -13,12 +13,12 @@ export type FilterToggleButtonProps = Omit<ToolbarButtonToggleProps, "checked">
     children: React.ReactNode;
 };
 /**
- * FilterToggleButton wraps ToolbarButtonToggle in a FilterItemWrapper for consistent overflow behavior with other filter types.
+ * FilterToggleButton wraps ToolbarButtonToggle in a FilterItemWrapper for
+ * consistent rendering with other filter types.
  * Built into FilterGroup for boolean filter rendering.
  *
  * Features:
  * - Renders a toggle button for boolean filters
- * - Integrates with FilterGroup and FilterItemWrapper for overflow handling
  * - Supports accessibility and keyboard navigation
  */
 export declare const FilterToggleButton: ({ id, checked, children, ...props }: FilterToggleButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/FilterBar/FilterTriggerButton.d.ts

@@ -0,0 +1,50 @@
+import { ReactNode } from 'react';
+import { ButtonProps } from '../../../components/Button';
+/**
+ * Props that drive the visual identity of a filter's bar trigger — shared by
+ * any popover/menu primitive that wants the standard filter-trigger styling.
+ *
+ * All other Button props (ref, onClick, onKeyDown, aria-*, data-state, …) are
+ * accepted via spread, which lets this component slot underneath any menu
+ * primitive's trigger render-prop (`SelectMenu`, `MultiSelectMenu`,
+ * `FilterDateSingle` / `FilterDateRange`'s popover shell) or, for `custom`,
+ * `FilterPopoverButton`'s `Popover.Button`.
+ */
+export type FilterTriggerButtonProps = Omit<ButtonProps, "children" | "icon"> & {
+    /** Filter id — emitted as `data-id` for test selectors and analytics. */
+    filterId: string;
+    /** Label content rendered inside the button. */
+    label: ReactNode;
+    /** Whether the filter has a committed selection (drives the selected-state class). */
+    isSelected: boolean;
+    /**
+     * Trigger icon.
+     * - `calendar` → leading Event icon (used by date-shaped filters)
+     * - `dropdown` → trailing chevron (default)
+     * @default "dropdown"
+     */
+    icon?: "calendar" | "dropdown";
+};
+/**
+ * FilterTriggerButton is the styled trigger primitive used by every popover-
+ * or menu-based filter type. It owns the visual identity (ghost appearance,
+ * toolbar-sized, selected-state, dropdown/calendar icon, data-id) and nothing
+ * else — open state and popover wiring belong to whatever component composes
+ * it (a menu's trigger render-prop, the date popover shells, or
+ * `FilterPopoverButton` for `custom`).
+ */
+export declare const FilterTriggerButton: import('react').ForwardRefExoticComponent<Omit<ButtonProps, "children" | "icon"> & {
+    /** Filter id — emitted as `data-id` for test selectors and analytics. */
+    filterId: string;
+    /** Label content rendered inside the button. */
+    label: ReactNode;
+    /** Whether the filter has a committed selection (drives the selected-state class). */
+    isSelected: boolean;
+    /**
+     * Trigger icon.
+     * - `calendar` → leading Event icon (used by date-shaped filters)
+     * - `dropdown` → trailing chevron (default)
+     * @default "dropdown"
+     */
+    icon?: "calendar" | "dropdown";
+} & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/src/beta/components/FilterBar/index.d.ts

@@ -1,3 +1,3 @@
 export * from './FilterBar';
 export { FilterBar as default, type FilterBarProps } from './FilterBar';
-export { type Filter, type BooleanFilter, type CustomFilter, type SingleSelectFilter, type MultiSelectFilter, type DateFilter, type DateRangeFilter, type DateListFilter, type DateListOption, type DateListLibraryOptionId, type FilterValue, type FilterRenderProps, type BaseFilter, } from './internal/types';
+export { type Filter, type BooleanFilter, type CustomFilter, type SingleSelectFilter, type MultiSelectFilter, type DateFilter, type DateRangeFilter, type DateListFilter, type DateListOption, type DateListLibraryOptionId, type AsyncSelectFilter, type AsyncMultiSelectFilter, type TreeFilter, type AsyncTreeFilter, type NumericRangeFilter, type NumericRangeValue, type TextInputFilter, type FilterValue, type FilterRenderProps, type BaseFilter, } from './internal/types';

package/dist/src/beta/components/FilterBar/internal/FilterGroupContext.d.ts

@@ -19,18 +19,14 @@ type FilterGroupContextProps = FilterBarProps & {
      *  @default () => {}
      */
     updateFilter: (filterId: string, value: FilterValue, submit: boolean) => void;
-    /** Array of filters that are currently hidden due to overflow
+    /** Filters configured as drawer-only — never rendered inline in the toolbar
      *  @default []
      */
-    hiddenFilters: Filter[];
-    /** Function to mark a filter as hidden
-     *  @default () => {}
-     */
-    addHiddenFilter: (filter: Filter) => void;
-    /** Function to mark a filter as visible
-     *  @default () => {}
+    drawerOnlyFilters: Filter[];
+    /** Whether the container is wide enough to render filters inline in the toolbar
+     *  @default false
      */
-    removeHiddenFilter: (filter: Filter) => void;
+    showInlineFilters: boolean;
 };
 /**
  * Context provider for filter-related operations

package/dist/src/beta/components/FilterBar/internal/adapters/asyncMultiSelect.d.ts

@@ -0,0 +1,6 @@
+import { MultiSelectMenuOption } from '../../../MultiSelectMenu';
+import { AsyncMultiSelectFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = MultiSelectMenuOption[];
+export declare const asyncMultiSelectAdapter: FilterTypeAdapter<AsyncMultiSelectFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/asyncSelect.d.ts

@@ -0,0 +1,6 @@
+import { SelectMenuOption } from '../../../SelectMenu';
+import { AsyncSelectFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = SelectMenuOption | undefined;
+export declare const asyncSelectAdapter: FilterTypeAdapter<AsyncSelectFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/asyncTree.d.ts

@@ -0,0 +1,6 @@
+import { TreeSelectMenuValue } from '../../../TreeSelectMenu';
+import { AsyncTreeFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = TreeSelectMenuValue[];
+export declare const asyncTreeAdapter: FilterTypeAdapter<AsyncTreeFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/boolean.d.ts

@@ -0,0 +1,3 @@
+import { BooleanFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+export declare const booleanAdapter: FilterTypeAdapter<BooleanFilter, boolean>;

package/dist/src/beta/components/FilterBar/internal/adapters/custom.d.ts

@@ -0,0 +1,3 @@
+import { CustomFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+export declare const customAdapter: FilterTypeAdapter<CustomFilter<unknown>, unknown>;

package/dist/src/beta/components/FilterBar/internal/adapters/date.d.ts

@@ -0,0 +1,5 @@
+import { DateFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = string | null;
+export declare const dateAdapter: FilterTypeAdapter<DateFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/dateList.d.ts

@@ -0,0 +1,5 @@
+import { DateListFilter, DateListOption } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = DateListOption | undefined;
+export declare const dateListAdapter: FilterTypeAdapter<DateListFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/dateRange.d.ts

@@ -0,0 +1,8 @@
+import { DateRangeFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = {
+    startDate: string | null;
+    endDate: string | null;
+} | null;
+export declare const dateRangeAdapter: FilterTypeAdapter<DateRangeFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/index.d.ts

@@ -0,0 +1,15 @@
+import { Filter } from '../types';
+import { FilterAdapters, FilterTypeAdapter } from './types';
+/**
+ * Per-type adapters keyed by Filter["type"]. Exhaustive: adding a new Filter
+ * variant forces a compile error here until an adapter is provided.
+ */
+export declare const filterAdapters: FilterAdapters;
+/**
+ * Looks up the adapter for a given filter. The returned adapter's F and V
+ * are widened to Filter / unknown — callers that need narrow typing should pass
+ * the filter directly through the adapter methods, which preserves variance.
+ * Falls back to a no-op adapter for unknown filter types.
+ */
+export declare const getAdapter: (filter: Filter) => FilterTypeAdapter<Filter, unknown>;
+export type { FilterTypeAdapter } from './types';

package/dist/src/beta/components/FilterBar/internal/adapters/multiSelect.d.ts

@@ -0,0 +1,6 @@
+import { MultiSelectMenuOption } from '../../../MultiSelectMenu';
+import { MultiSelectFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = MultiSelectMenuOption[];
+export declare const multiSelectAdapter: FilterTypeAdapter<MultiSelectFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/numericRange.d.ts

@@ -0,0 +1,3 @@
+import { NumericRangeFilter, NumericRangeValue } from '../types';
+import { FilterTypeAdapter } from './types';
+export declare const numericRangeAdapter: FilterTypeAdapter<NumericRangeFilter, NumericRangeValue>;

package/dist/src/beta/components/FilterBar/internal/adapters/singleSelect.d.ts

@@ -0,0 +1,6 @@
+import { SelectMenuOption } from '../../../SelectMenu';
+import { SingleSelectFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = SelectMenuOption | undefined;
+export declare const singleSelectAdapter: FilterTypeAdapter<SingleSelectFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/textInput.d.ts

@@ -0,0 +1,3 @@
+import { TextInputFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+export declare const textInputAdapter: FilterTypeAdapter<TextInputFilter, string>;

package/dist/src/beta/components/FilterBar/internal/adapters/tree.d.ts

@@ -0,0 +1,6 @@
+import { TreeSelectMenuValue } from '../../../TreeSelectMenu';
+import { TreeFilter } from '../types';
+import { FilterTypeAdapter } from './types';
+type Value = TreeSelectMenuValue[];
+export declare const treeAdapter: FilterTypeAdapter<TreeFilter, Value>;
+export {};

package/dist/src/beta/components/FilterBar/internal/adapters/types.d.ts

@@ -0,0 +1,81 @@
+import { ReactNode } from 'react';
+import { AsyncMultiSelectFilter, AsyncSelectFilter, BooleanFilter, CustomFilter, DateFilter, DateListFilter, DateListLibraryOptionId, DateRangeFilter, Filter, MultiSelectFilter, NumericRangeFilter, SingleSelectFilter, TextInputFilter, TreeFilter, AsyncTreeFilter } from '../types';
+/**
+ * Context passed to renderBarControl — the inline FilterBar control for a filter.
+ *
+ * `controlledFiltering` mirrors the FilterBar prop of the same name: when true,
+ * select-style adapters should opt their underlying menu into confirmation mode
+ * (clicks update a draft, Apply commits, dismiss cancels).
+ */
+export type BarControlRenderCtx<F extends Filter> = {
+    filter: F;
+    updateFilter: (filterId: string, value: unknown, submit: boolean) => void;
+    controlledFiltering: boolean;
+};
+/**
+ * Context passed to renderDrawer — the FilterDrawer form control for a filter.
+ * Receives both the draft filter (with current draft selection) and the
+ * original filter (for stable references to consumer-supplied data).
+ *
+ * `requestDateListDialog` is provided so the dateList adapter can ask the drawer
+ * to open its shared DateListDialog when a library option is picked.
+ */
+export type DrawerRenderCtx<F extends Filter> = {
+    originalFilter: F;
+    draftFilter: F;
+    onDraftChange: (filterId: string, value: unknown) => void;
+    requestDateListDialog: (filterId: string, libraryId: DateListLibraryOptionId) => void;
+};
+/**
+ * Per-filter-type adapter. Each filter variant contributes one adapter
+ * implementing every operation FilterBar / FilterDrawer need.
+ *
+ * F = the specific Filter variant
+ * V = the value type (what getValue / setValue traffic in)
+ *
+ * `renderBarControl` returns the complete inline UI for this filter type.
+ * Most adapters compose `SelectMenu` / `MultiSelectMenu` (or one of the
+ * filter-specific shells like `FilterDateSingle`) directly, supplying the
+ * trigger via render-prop. The `custom` adapter composes `FilterPopoverButton`
+ * for fully consumer-rendered popover bodies; `boolean` uses a toggle button
+ * with no popover at all. The adapter type itself stays agnostic about UI
+ * shape.
+ */
+export type FilterTypeAdapter<F extends Filter, V> = {
+    getValue: (filter: F) => V;
+    setValue: (filter: F, value: V) => F;
+    reset: (filter: F) => F;
+    isActive: (filter: F) => boolean;
+    preserveState: (newFilter: F, existingFilter: F) => F;
+    cloneWithItemRefs: (filter: F) => F;
+    renderBarControl: (ctx: BarControlRenderCtx<F>) => ReactNode;
+    renderDrawer: (ctx: DrawerRenderCtx<F>) => ReactNode;
+    formatLabel: (filter: F) => ReactNode;
+    isSelected: (filter: F) => boolean;
+};
+/**
+ * Map from a Filter's `type` discriminant to its specific variant.
+ * Used to keep the adapter map exhaustive at the type level.
+ */
+export type FilterVariantMap = {
+    boolean: BooleanFilter;
+    custom: CustomFilter<any>;
+    singleSelect: SingleSelectFilter;
+    multiSelect: MultiSelectFilter;
+    date: DateFilter;
+    dateRange: DateRangeFilter;
+    dateList: DateListFilter;
+    asyncSelect: AsyncSelectFilter;
+    asyncMultiSelect: AsyncMultiSelectFilter;
+    tree: TreeFilter;
+    asyncTree: AsyncTreeFilter;
+    numericRange: NumericRangeFilter;
+    textInput: TextInputFilter;
+};
+/**
+ * Exhaustive map from Filter["type"] to its adapter. Forces compile-time
+ * completeness when a new filter type is added.
+ */
+export type FilterAdapters = {
+    [K in keyof FilterVariantMap]: FilterTypeAdapter<FilterVariantMap[K], any>;
+};