themelia-react-ui 0.0.0-stage → 1.0.0

package/dist/components/features/filters/facets/range-facet.d.ts

@@ -0,0 +1,30 @@
+import type { FilterConfig } from '../filters.types';
+export interface RangeFacetProps {
+    /** Definition of the filter this control edits. */
+    filter: FilterConfig;
+    /** Current value. */
+    value: {
+        min?: number;
+        max?: number;
+    };
+    /** Fired with the next value. */
+    onValueChange: (value: {
+        min?: number;
+        max?: number;
+    }) => void;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+/**
+ * Range Filter Facet
+ *
+ * This component implements a numeric range filter that allows users to:
+ * - Set minimum and maximum values
+ * - Configure step size and precision
+ * - Set value constraints (min/max allowed values)
+ * - Customize the range input appearance
+ *
+ * The component integrates with the filter context to manage the range values
+ * and provides a user-friendly interface for range selection.
+ */
+export declare function RangeFacet({ filter, value, onValueChange, className, }: RangeFacetProps): import("react").JSX.Element;

package/dist/components/features/filters/facets/search-facet.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { FilterConfig } from '../filters.types';
+export interface SearchFacetProps {
+    /** Definition of the filter this control edits. */
+    filter: FilterConfig;
+    /** Current value. */
+    value: string[];
+    /** Fired with the next value. */
+    onValueChange: (value: string[]) => void;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+/**
+ * Search Filter Facet
+ *
+ * This component implements a text search filter that allows users to:
+ * - Enter search terms
+ * - Configure search behavior (contains, equals, etc.)
+ * - Set debounce delay for performance
+ * - Customize placeholder text and appearance
+ *
+ * The component integrates with the filter context to manage the search value
+ * and provides a responsive search input interface.
+ */
+declare function SearchFacetComponent({ filter, value, onValueChange, className, }: SearchFacetProps): React.JSX.Element;
+export declare const SearchFacet: React.MemoExoticComponent<typeof SearchFacetComponent>;
+export {};

package/dist/components/features/filters/facets/select-facet.d.ts

@@ -0,0 +1,19 @@
+import type { FilterConfig } from '../filters.types';
+export interface SelectFacetProps {
+    /** Definition of the filter this control edits. */
+    filter: FilterConfig;
+    /** Current value. */
+    value: string[];
+    /** Fired with the next value. */
+    onValueChange: (value: string[]) => void;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+/**
+ * SelectFacet — single/multi-select dropdown filter.
+ *
+ * Composes `PopoverMenu` for the popover + searchable list pattern.
+ * Multi-select keeps the popover open after a tap; single-select closes
+ * unless `closeOnSelect=false` is passed in the filter config.
+ */
+export declare function SelectFacet({ filter, value, onValueChange, className, }: SelectFacetProps): import("react").JSX.Element;

package/dist/components/features/filters/facets/tags-facet.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { type FilterConfig } from '../filters.types';
+export interface TagsFacetProps {
+    /** Definition of the filter this control edits. */
+    filter: FilterConfig;
+    /** Current value. */
+    value: string[];
+    /** Fired with the next value. */
+    onValueChange: (value: string[]) => void;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+/**
+ * Tags Filter Facet
+ *
+ * This component implements a tags input filter that allows users to:
+ * - Enter tags through an input field
+ * - Add tags by pressing Enter or clicking the add button
+ * - View all selected tags as removable badges
+ * - Remove individual tags by clicking the X on each badge
+ *
+ * The component is ideal for filtering by multiple tags or keywords
+ * where users need to see all selected values at once.
+ */
+declare function TagsFacetComponent({ filter, value, onValueChange, className, }: TagsFacetProps): React.JSX.Element;
+export declare const TagsFacet: React.MemoExoticComponent<typeof TagsFacetComponent>;
+export {};

package/dist/components/features/filters/filter-context.d.ts

@@ -0,0 +1,61 @@
+/**
+ * bem-exempt: FilterProvider renders only <FilterContext.Provider>, which is
+ * not a DOM node. CONVENTIONS.md §8 requires the {name}--component hook to land
+ * on a real rendered element and explicitly forbids putting it on a context
+ * provider. Filter chrome carries its own hooks in `partials/`.
+ */
+import { type ReactNode } from 'react';
+import { type StringsProp } from '../../../lib/strings';
+import { type FilterStrings } from './filters.strings';
+import { type FilterConfig, type ActiveFilter, type FilterOperator, type FilterOption, type FilterErrorHandler } from './filters.types';
+export interface FilterProviderProps {
+    children: ReactNode;
+    /** Filter definitions available to the surface. */
+    filters: FilterConfig[];
+    /** Filters currently applied. */
+    activeFilters: ActiveFilter[];
+    /** Fired when the change filters change. */
+    onFilterChange: (filters: ActiveFilter[]) => void;
+    /** Whether a filter change is still being applied. */
+    navigating?: boolean;
+    /** Overrides this surface's own copy. */
+    strings?: StringsProp<FilterStrings>;
+    /** Called when an async fetch, validation, apply, or render step throws.
+     *  Library DEV-logs the error; consumer wires telemetry here. */
+    onError?: FilterErrorHandler;
+}
+export interface FilterContextValue {
+    /** Filters currently applied. */
+    activeFilters: ActiveFilter[];
+    /** Filter definitions available to the surface. */
+    filters: FilterConfig[];
+    addFilter: (filter: ActiveFilter) => void;
+    removeFilter: (id: string) => void;
+    updateFilter: (id: string, updates: Partial<ActiveFilter>) => void;
+    clearFilters: () => void;
+    replaceFilters: (filters: ActiveFilter[]) => void;
+    getFilterByKey: (key: string) => FilterConfig | undefined;
+    getFilterValue: (key: string) => string[];
+    setFilterValue: (key: string, value: string[]) => void;
+    isFilterActive: (key: string) => boolean;
+    getFilterOperator: (key: string) => FilterOperator | undefined;
+    setFilterOperator: (key: string, operator: FilterOperator) => void;
+    validateFilter: (key: string, value: unknown) => boolean | string;
+    getDependentFilters: (key: string) => FilterConfig[];
+    /** Whether a filter change is still being applied. */
+    isNavigating: boolean;
+    /** Overrides this surface's own copy. */
+    strings: FilterStrings;
+    /** Cache resolved options for async filters (keyed by filter key → option value → FilterOption) */
+    cacheAsyncOptions: (filterKey: string, options: FilterOption[]) => void;
+    /** Resolve a cached label for an async filter value */
+    getAsyncOptionLabel: (filterKey: string, optionValue: string) => string | undefined;
+    /** Report feature-level errors through the provider callback. */
+    reportError: FilterErrorHandler;
+}
+/**
+ * Framework-agnostic filter provider.
+ * State, strings, and async option fetchers are passed by the consumer.
+ */
+export declare function FilterProvider({ children, filters, activeFilters, onFilterChange, navigating: isNavigatingProp, strings: stringsProp, onError, }: FilterProviderProps): import("react").JSX.Element;
+export declare function useFilters(): FilterContextValue;

package/dist/components/features/filters/filter-layout.d.ts

@@ -0,0 +1,16 @@
+import { type FilterConfig, type FilterTab } from './filters.types';
+export interface FilterLayoutProps {
+    /** Merged onto the outermost node. */
+    className?: string;
+    /** Per-key dynamic options that override the provider's filter.options. */
+    dynamicFilterOptions?: Record<string, FilterConfig['options']>;
+    /** Per-key loading states; renders a small spinning chip. */
+    loadingFilters?: Record<string, boolean>;
+    /** The variant this surface represents. */
+    variant?: 'default' | 'compact';
+    /** Renders the clear filters. */
+    showClearFilters?: boolean;
+    /** Tabs to offer, in display order. */
+    tabs?: FilterTab[];
+}
+export declare function FilterLayout({ className, dynamicFilterOptions, loadingFilters, variant, showClearFilters, tabs, }: FilterLayoutProps): import("react").JSX.Element;

package/dist/components/features/filters/filter-query.d.ts

@@ -0,0 +1,21 @@
+import { type ActiveFilter, type FilterConfig } from './filters.types';
+export type FilterQueryValue = string | number | boolean | null | undefined | readonly (string | number | boolean | null | undefined)[];
+export type FilterQueryRecord = Record<string, string | string[] | undefined>;
+export type FilterQueryInput = URLSearchParams | Record<string, FilterQueryValue>;
+export type FilterQueryArrayFormat = 'repeat' | 'comma';
+export type FilterQueryOperatorMode = 'changed' | 'always' | 'never';
+export interface FilterQueryOptions {
+    /** Suffix for the companion operator query key. Default: `__op`. */
+    operatorSuffix?: string;
+    /** Array encoding for multi-value filters. Default: repeated keys/string arrays. */
+    arrayFormat?: FilterQueryArrayFormat;
+    /** Keep unrelated query keys while serializing filters. Default: true. */
+    preserveUnrelated?: boolean;
+    /** Query keys to remove when filters change. Default: `['page']`. */
+    resetPageKeys?: readonly string[];
+    /** Include filter operator query keys. Default: only when not the configured default. */
+    includeOperators?: FilterQueryOperatorMode;
+}
+export declare function parseFiltersFromQuery(filterConfigs: readonly FilterConfig[], query: FilterQueryInput, options?: FilterQueryOptions): ActiveFilter[];
+export declare function serializeFiltersToQuery(filterConfigs: readonly FilterConfig[], activeFilters: readonly ActiveFilter[], currentQuery?: FilterQueryInput, options?: FilterQueryOptions): FilterQueryRecord;
+export declare function mergeFilterQuery(currentQuery: FilterQueryInput, nextFilterQuery: FilterQueryInput, options?: Pick<FilterQueryOptions, 'preserveUnrelated' | 'resetPageKeys'>): FilterQueryRecord;

package/dist/components/features/filters/filters.strings.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Filter strings — default copy and nested override contract.
+ *
+ * Consumers localize filters by passing `strings` to `<FilterProvider>`.
+ * No routing, framework i18n hook, or backend shared-props contract belongs in
+ * this default feature path.
+ */
+export interface FilterOperatorStrings {
+    contains: string;
+    equals: string;
+    notContains: string;
+    is: string;
+    isNot: string;
+    greaterThan: string;
+    lessThan: string;
+    before: string;
+    after: string;
+    between: string;
+    has: string;
+    hasAny: string;
+    hasAll: string;
+}
+export interface FilterStrings {
+    loading: string;
+    loadingOptions: string;
+    addFilter: string;
+    clear: string;
+    confirm: string;
+    clearFilters: string;
+    clearAll: string;
+    selectDate: string;
+    selectDateRange: string;
+    calendar: {
+        dateSelected: string;
+        notDateSelected: string;
+        notDateRangeSelected: string;
+        selectedEndDate: string;
+        today: string;
+        yesterday: string;
+        lastSevenDays: string;
+        lastThirtyDays: string;
+        thisMonth: string;
+        lastMonth: string;
+        thisYear: string;
+        lastYear: string;
+        customRange: string;
+    };
+    selectValues: string;
+    searchPlaceholder: string;
+    noOptionsFound: string;
+    /** Whether the entry is selected. */
+    selected: string;
+    nothingSelected: string;
+    enterTag: string;
+    addTag: string;
+    removeTag: string;
+    tag: string;
+    tags: string;
+    enterTags: string;
+    searchFilters: string;
+    noFiltersAvailable: string;
+    availableFilters: string;
+    activeFilters: string;
+    clearSearch: string;
+    backToFilters: string;
+    select: string;
+    options: string;
+    operator: string;
+    operators: FilterOperatorStrings;
+    min: string;
+    max: string;
+    fetchError: string;
+    retryFetch: string;
+    minQueryHint: string;
+    searching: string;
+    error: {
+        title: string;
+        descriptionWithKey: string;
+        generic: string;
+        unknown: string;
+    };
+    validation: {
+        required: string;
+        minValue: string;
+        maxValue: string;
+        invalidFormat: string;
+    };
+}
+/**
+ * Default English strings for the filter system.
+ * These serve as fallbacks when no strings are provided.
+ */
+export declare const defaultFilterStrings: FilterStrings;
+/**
+ * Helper function to interpolate values in strings.
+ * Replaces {key} with the corresponding value from the params object.
+ */
+export declare function interpolateFilterString(template: string, params: Record<string, string | number>): string;
+/**
+ * Helper function to get a string from a strings object
+ * with dot notation support.
+ */
+export declare function getFilterString(strings: FilterStrings, path: string, params?: Record<string, string | number>): string;

package/dist/components/features/filters/filters.types.d.ts

@@ -0,0 +1,222 @@
+import type { ReactNode } from 'react';
+/** Shared height class for all filter control elements. */
+export declare const FILTER_ELEMENT_HEIGHT = "h-control";
+/**
+ * Core type definitions and interfaces for the filters feature.
+ *
+ * This file defines:
+ * - Filter types (SELECT, MULTI_SELECT, SEARCH, RANGE, DATE)
+ * - Filter operators (equals, contains, in, etc.)
+ * - Configuration interfaces for filters
+ * - Context value types for filter state management
+ * - Validation and display configuration types
+ *
+ * These types are used throughout the filters feature to ensure type safety
+ * and consistent data structures.
+ */
+export declare const FilterType: {
+    readonly SELECT: "select";
+    readonly MULTI_SELECT: "multi_select";
+    readonly ASYNC_SELECT: "async_select";
+    readonly SEARCH: "search";
+    readonly RANGE: "range";
+    readonly DATE: "date";
+    readonly TAGS: "tags";
+};
+export type FilterType = (typeof FilterType)[keyof typeof FilterType];
+export declare const FilterOperatorEnum: {
+    readonly EQUALS: "equals";
+    readonly CONTAINS: "contains";
+    readonly IN: "in";
+    readonly NOT_IN: "not_in";
+    readonly NOT: "not";
+    readonly BEFORE: "before";
+    readonly AFTER: "after";
+    readonly BETWEEN: "between";
+    readonly GT: "gt";
+    readonly LT: "lt";
+    readonly GTE: "gte";
+    readonly LTE: "lte";
+    readonly HAS: "has";
+    readonly HAS_ANY: "has_any";
+    readonly HAS_ALL: "has_all";
+};
+export type FilterOperator = (typeof FilterOperatorEnum)[keyof typeof FilterOperatorEnum];
+export interface OperatorOption {
+    /** Display label. */
+    label: string;
+    /** Current value of the filter. */
+    value: FilterOperator;
+}
+export type FilterDisplay = 'always' | 'drawer' | 'collapsed' | 'hidden';
+/** Origin of a filter editor, used to decide whether a back action is available. */
+export type FilterTriggerSource = 'toolbar' | 'chip';
+export declare const FilterCategory: {
+    readonly FILTER: "filter";
+    readonly SORT: "sort";
+    readonly GROUP: "group";
+};
+export type FilterCategory = (typeof FilterCategory)[keyof typeof FilterCategory];
+export interface FilterOption {
+    /** Display label. */
+    label: string;
+    /** Current value of the filter. */
+    value: string;
+    /** Leading glyph. */
+    icon: ReactNode;
+    children?: FilterOption[];
+    /** Renders the entry as unselectable. */
+    disabled?: boolean;
+    /** Supporting copy shown under the label. */
+    description?: string;
+    color?: string;
+}
+export interface DisplayConfig {
+    /** Replaces the default config rendering. */
+    renderConfig?: {
+        desktop: string;
+        mobile?: string;
+        tablet?: string;
+    };
+    display?: FilterDisplay;
+    category?: FilterCategory;
+    priority?: number;
+    hidden?: boolean;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+export interface ValidationConfig {
+    min?: number;
+    max?: number;
+    pattern?: RegExp;
+    required?: boolean;
+    custom?: (value: unknown) => boolean | string;
+}
+export interface FilterDependency {
+    key: string;
+    /** Comparison currently chosen. */
+    operator: FilterOperator;
+    /** Current value of the filter. */
+    value: string | string[];
+}
+export interface FilterErrorContext {
+    phase: 'fetch-options' | 'apply' | 'validate' | 'render';
+    filterKey?: string;
+}
+export type FilterErrorHandler = (error: unknown, context: FilterErrorContext) => void;
+/**
+ * Configuration for ASYNC_SELECT filters that load options asynchronously.
+ *
+ * The single async channel owns search, caching, abort, and preload control.
+ * Static SELECT and MULTI_SELECT filters use `FilterConfig.options` instead.
+ */
+export interface AsyncSelectConfig<TItem = unknown> {
+    /** Cache key factory — receives { query, limit } and returns a stable key. */
+    queryKey: (args: {
+        query: string;
+        limit: number;
+    }) => readonly unknown[];
+    /** Fetcher function — receives { query, limit, signal } and returns items */
+    fetcher: (args: {
+        query: string;
+        limit: number;
+        signal?: AbortSignal;
+    }) => Promise<TItem[]>;
+    /** Maps a fetched item to a FilterOption for display. */
+    mapToOption: {
+        bivarianceHack(item: TItem): FilterOption;
+    }['bivarianceHack'];
+    /** Max items to fetch per request (default: 10) */
+    limit?: number;
+    /** Minimum characters before fetching (default: 0) */
+    minQueryLength?: number;
+    /** Whether to fetch with empty query on open (default: true) */
+    preload?: boolean;
+    /** Debounce delay in ms (default: 300) */
+    debounceMs?: number;
+    /** Freshness window in ms before a cached result refetches (default: 60_000). */
+    staleTime?: number;
+    /** Retention window in ms before a cached result is discarded (default: 300_000). */
+    gcTime?: number;
+}
+/**
+ * Infers the fetched item shape once and preserves it across `fetcher` and
+ * `mapToOption`, while remaining assignable to heterogeneous filter arrays.
+ */
+export declare function defineAsyncSelectConfig<TItem>(config: AsyncSelectConfig<TItem>): AsyncSelectConfig<TItem>;
+export interface FilterConfig {
+    key: string;
+    /** Display label. */
+    label: string;
+    /** Plural form of the label, used in "{count} {label} selected" when count > 1 */
+    pluralLabel?: string;
+    type: FilterType;
+    /** Supporting copy shown under the label. */
+    description?: string;
+    /** Comparison currently chosen. */
+    operator?: FilterOperator;
+    /** Comparisons this filter offers. */
+    operators?: OperatorOption[];
+    options?: FilterOption[];
+    placeholder?: string;
+    delay?: number;
+    /** Leading glyph. */
+    icon: ReactNode;
+    displayConfig: DisplayConfig;
+    defaultValue?: string | string[];
+    validation?: ValidationConfig;
+    dependencies?: FilterDependency[];
+    multiple?: boolean;
+    closeOnSelect?: boolean;
+    maxSelected?: number;
+    /** Async option loading config for ASYNC_SELECT filters. */
+    asyncConfig?: AsyncSelectConfig;
+    dateFormat?: {
+        display?: string;
+        param?: string;
+    };
+    datePickerConfig?: {
+        showConfirmButton?: boolean;
+        showShortcuts?: boolean;
+        fullWidth?: boolean;
+        noDatePlaceholder?: string;
+        noRangePlaceholder?: string;
+        autoApply?: boolean;
+    };
+    format?: (value: unknown) => string;
+    parse?: (value: string) => unknown;
+    transform?: (value: unknown) => unknown;
+}
+export interface ActiveFilter {
+    /** Stable identity for this entry. */
+    id: string;
+    key: string;
+    /** Comparison currently chosen. */
+    operator: FilterOperator;
+    /** Current value of the filter. */
+    value: string[];
+}
+export interface FilterGroup {
+    /** Display label. */
+    label: string;
+    /** Filter definitions available to the surface. */
+    filters: FilterConfig[];
+}
+export interface FilterState {
+    [key: string]: string[];
+}
+export interface FilterTabPreset {
+    key: string;
+    /** Current value of the filter. */
+    value: string[];
+    /** Comparison currently chosen. */
+    operator?: FilterOperator;
+}
+export interface FilterTab {
+    /** Stable identity for this entry. */
+    id: string;
+    /** Display label. */
+    label: string;
+    presets: FilterTabPreset[];
+    count?: number;
+}

package/dist/components/features/filters/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useAsyncOptions } from './use-async-options';
+export type { UseAsyncOptionsOptions, UseAsyncOptionsResult, } from './use-async-options';
+export { useFilterGroups, type UseFilterGroupsOptions, type UseFilterGroupsResult, } from './use-filter-groups';

package/dist/components/features/filters/hooks/use-async-options.d.ts

@@ -0,0 +1,16 @@
+import type { FilterConfig, FilterErrorHandler, FilterOption } from '../filters.types';
+export interface UseAsyncOptionsResult {
+    options: FilterOption[];
+    /** Replaces the content with the loading state. */
+    isLoading: boolean;
+    isFetching: boolean;
+    isError: boolean;
+    refetch: () => void;
+    isBelowMinQuery: boolean;
+    minQueryLength: number;
+}
+export interface UseAsyncOptionsOptions {
+    /** Receives non-abort fetch failures after stale requests have been discarded. */
+    onError?: FilterErrorHandler;
+}
+export declare function useAsyncOptions(filter: FilterConfig, searchInput: string, isActive: boolean, options?: UseAsyncOptionsOptions): UseAsyncOptionsResult;

package/dist/components/features/filters/hooks/use-filter-groups.d.ts

@@ -0,0 +1,16 @@
+import { type FilterConfig } from '../filters.types';
+export interface UseFilterGroupsOptions {
+    /** Override `filter.options` per-key at render time. */
+    dynamicFilterOptions?: Record<string, FilterConfig['options']>;
+}
+export interface UseFilterGroupsResult {
+    /** Filters merged with `dynamicFilterOptions`. */
+    processedFilters: FilterConfig[];
+    searchFilters: FilterConfig[];
+    alwaysVisibleFilters: FilterConfig[];
+    activeRegularFilters: FilterConfig[];
+    popoverFilters: FilterConfig[];
+    activeFilterKeys: string[];
+    hasActive: boolean;
+}
+export declare function useFilterGroups(options?: UseFilterGroupsOptions): UseFilterGroupsResult;

package/dist/components/features/filters/index.d.ts

@@ -0,0 +1,42 @@
+export { FilterProvider, useFilters } from './filter-context';
+export type { FilterContextValue, FilterProviderProps } from './filter-context';
+export { FilterLayout } from './filter-layout';
+export type { FilterLayoutProps } from './filter-layout';
+export type { FilterConfig, FilterOption, ActiveFilter, FilterOperator, OperatorOption, FilterDependency, ValidationConfig, DisplayConfig, FilterTab, FilterTabPreset, AsyncSelectConfig, FilterErrorContext, FilterErrorHandler, } from './filters.types';
+export { FilterType, FilterOperatorEnum, defineAsyncSelectConfig, } from './filters.types';
+export { mergeFilterQuery, parseFiltersFromQuery, serializeFiltersToQuery, type FilterQueryArrayFormat, type FilterQueryInput, type FilterQueryOperatorMode, type FilterQueryOptions, type FilterQueryRecord, type FilterQueryValue, } from './filter-query';
+export { defaultFilterStrings, getFilterString, interpolateFilterString, } from './filters.strings';
+export type { FilterOperatorStrings, FilterStrings, } from './filters.strings';
+export { getTextOperators, getSelectOperators, getNumberOperators, getDateOperators, getBooleanOperators, getOperatorsForType, getDefaultOperatorForType, } from './operator-options';
+export { SearchFacet } from './facets/search-facet';
+export type { SearchFacetProps } from './facets/search-facet';
+export { SelectFacet } from './facets/select-facet';
+export type { SelectFacetProps } from './facets/select-facet';
+export { AsyncSelectFacet } from './facets/async-select-facet';
+export type { AsyncSelectFacetProps } from './facets/async-select-facet';
+export { DateFacet } from './facets/date-facet';
+export type { DateFacetProps } from './facets/date-facet';
+export { RangeFacet } from './facets/range-facet';
+export type { RangeFacetProps } from './facets/range-facet';
+export { TagsFacet } from './facets/tags-facet';
+export type { TagsFacetProps } from './facets/tags-facet';
+export { ActiveFilterItem } from './partials/active-filter-item';
+export type { ActiveFilterItemProps } from './partials/active-filter-item';
+export { FilterOperatorSelect } from './partials/filter-operator-select';
+export type { FilterOperatorSelectProps } from './partials/filter-operator-select';
+export { FilterPill } from './partials/filter-pill';
+export type { FilterPillProps } from './partials/filter-pill';
+export { FilterPopoverContent } from './partials/filter-popover-content';
+export type { FilterPopoverContentProps } from './partials/filter-popover-content';
+export { FilterValueDisplay } from './partials/filter-value-display';
+export type { FilterValueDisplayProps } from './partials/filter-value-display';
+export { FiltersButton } from './partials/filters-button';
+export type { FiltersButtonProps } from './partials/filters-button';
+export { FilterTabs } from './partials/filter-tabs';
+export type { FilterTabsProps } from './partials/filter-tabs';
+export { SearchFiltersList } from './partials/search-filters-list';
+export type { SearchFiltersListProps } from './partials/search-filters-list';
+export { FilterErrorBoundary } from './partials/filter-error-boundary';
+export type { FilterErrorBoundaryProps } from './partials/filter-error-boundary';
+export { useAsyncOptions, useFilterGroups, type UseAsyncOptionsOptions, type UseAsyncOptionsResult, type UseFilterGroupsOptions, type UseFilterGroupsResult, } from './hooks';
+export { zodValidator, predicateValidator, type SafeParseSchema, } from './validators';

package/dist/components/features/filters/operator-options.d.ts

@@ -0,0 +1,9 @@
+import { type FilterOperator, type OperatorOption, FilterType } from './filters.types';
+import type { FilterOperatorStrings } from './filters.strings';
+export declare function getTextOperators(strings: FilterOperatorStrings): OperatorOption[];
+export declare function getSelectOperators(strings: FilterOperatorStrings): OperatorOption[];
+export declare function getNumberOperators(strings: FilterOperatorStrings): OperatorOption[];
+export declare function getDateOperators(strings: FilterOperatorStrings): OperatorOption[];
+export declare function getBooleanOperators(strings: FilterOperatorStrings): OperatorOption[];
+export declare function getOperatorsForType(type: FilterType, strings: FilterOperatorStrings): OperatorOption[];
+export declare function getDefaultOperatorForType(type: FilterType): FilterOperator;

package/dist/components/features/filters/partials/active-filter-item.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { type FilterConfig, type FilterOperator, type OperatorOption } from '../filters.types';
+export interface ActiveFilterItemProps {
+    /** Definition of the filter this control edits. */
+    filter: FilterConfig;
+    /** Current value. */
+    value: string[];
+    /** Whether the filter is currently applied. */
+    active: boolean;
+    /** Whether the filter editor is open. */
+    popoverOpen?: boolean;
+    /** Ref to the visible editor trigger for focus restoration. */
+    triggerRef?: React.Ref<HTMLButtonElement>;
+    /** Comparisons this filter offers. */
+    operators: OperatorOption[];
+    /** Comparison currently chosen. */
+    operator: FilterOperator;
+    onOperatorChange: (operator: FilterOperator) => void;
+    /** Fired when the clear filters change. */
+    onFilterClear: () => void;
+    /** Opens the value editor from either segment; the optional event identifies its focus origin. */
+    onFilterClick: (event?: React.MouseEvent<HTMLButtonElement>) => void;
+}
+/**
+ * Active Filter Item Component
+ *
+ * This component displays a single active filter in the filter list.
+ * It provides:
+ * - Display of filter label and value
+ * - Remove filter functionality
+ * - Visual feedback for active state
+ * - Support for different filter types
+ *
+ * The component is used in the filter list to show currently active filters
+ * and allow users to remove them.
+ */
+export declare function ActiveFilterItem({ filter, value, active, popoverOpen, triggerRef, operators, operator, onOperatorChange, onFilterClear, onFilterClick, }: ActiveFilterItemProps): React.JSX.Element;