@wallarm-org/design-system 1.28.2-rc-fix-table-window-scroll-root.2 → 1.30.0

package/dist/components/FilterDropdown/FilterDropdownClear.js

@@ -0,0 +1,33 @@
+import { jsx } from "react/jsx-runtime";
+import { X } from "../../icons/index.js";
+import { cn } from "../../utils/cn.js";
+import { useTestId } from "../../utils/testId.js";
+import { filterDropdownClearClassName } from "./classes.js";
+import { useFilterDropdownContext } from "./FilterDropdownContext.js";
+const FilterDropdownClear = ({ ref, className, children, disabled, onClick, 'aria-label': ariaLabel, 'data-testid': testIdProp, ...props })=>{
+    const { multiple, value, label, clear, triggerRef, disabled: rootDisabled } = useFilterDropdownContext();
+    const testId = useTestId('clear', testIdProp);
+    if (!multiple || 0 === value.length) return null;
+    const handleClick = (event)=>{
+        onClick?.(event);
+        if (event.defaultPrevented) return;
+        triggerRef.current?.focus();
+        clear();
+    };
+    return /*#__PURE__*/ jsx("button", {
+        type: "button",
+        ...props,
+        ref: ref,
+        "data-slot": "filter-dropdown-clear",
+        "data-testid": testId,
+        "aria-label": ariaLabel ?? `Clear ${label}`,
+        disabled: rootDisabled || disabled,
+        onClick: handleClick,
+        className: cn(filterDropdownClearClassName, className),
+        children: children ?? /*#__PURE__*/ jsx(X, {
+            size: "md"
+        })
+    });
+};
+FilterDropdownClear.displayName = 'FilterDropdownClear';
+export { FilterDropdownClear };

package/dist/components/FilterDropdown/FilterDropdownContent.d.ts

@@ -0,0 +1,13 @@
+import { type FC, type ReactNode, type Ref } from 'react';
+import type { Select as ArkUiSelect } from '@ark-ui/react/select';
+import { type TestableProps } from '../../utils/testId';
+export interface FilterDropdownContentProps extends Omit<ArkUiSelect.ContentProps, 'asChild' | 'children'>, TestableProps {
+    ref?: Ref<HTMLDivElement>;
+    children?: ReactNode;
+}
+/**
+ * The menu panel. `FilterDropdownSearch` children are pinned above the scrolling list and
+ * `FilterDropdownFooter` children below it; everything else scrolls. Hugs its options up to
+ * 360px and at most 340px tall, and keeps its width while a query narrows the list.
+ */
+export declare const FilterDropdownContent: FC<FilterDropdownContentProps>;

package/dist/components/FilterDropdown/FilterDropdownContent.js

@@ -0,0 +1,57 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Children, isValidElement } from "react";
+import { cn } from "../../utils/cn.js";
+import { mergeRefs } from "../../utils/mergeRefs.js";
+import { TestIdProvider, useTestId } from "../../utils/testId.js";
+import { SelectContent } from "../Select/SelectContent.js";
+import { SelectHeader } from "../Select/SelectHeader.js";
+import { SelectPositioner } from "../Select/SelectPositioner.js";
+import { filterDropdownContentClassName } from "./classes.js";
+import { useFilterDropdownContext } from "./FilterDropdownContext.js";
+import { FilterDropdownFooter } from "./FilterDropdownFooter.js";
+import { FilterDropdownSearch } from "./FilterDropdownSearch.js";
+const FilterDropdownContent = ({ ref, className, style, children, 'data-testid': testIdProp, ...props })=>{
+    const { isSearchable, isSearchActive, lockedWidth, contentRef } = useFilterDropdownContext();
+    const testId = useTestId('content', testIdProp);
+    const listTestId = useTestId('list');
+    const baseTestId = useTestId();
+    const header = [];
+    const footer = [];
+    const body = [];
+    Children.forEach(children, (child)=>{
+        if (/*#__PURE__*/ isValidElement(child) && child.type === FilterDropdownSearch) header.push(child);
+        else if (/*#__PURE__*/ isValidElement(child) && child.type === FilterDropdownFooter) footer.push(child);
+        else body.push(child);
+    });
+    const width = isSearchActive && lockedWidth ? lockedWidth : void 0;
+    return /*#__PURE__*/ jsxs(SelectPositioner, {
+        className: cn(filterDropdownContentClassName, className),
+        contentProps: {
+            ...props,
+            ref: mergeRefs(ref, contentRef),
+            style: void 0 === width ? style : {
+                ...style,
+                width
+            },
+            'data-slot': 'filter-dropdown-content',
+            'data-testid': testId
+        },
+        children: [
+            isSearchable && header.length > 0 && /*#__PURE__*/ jsx(SelectHeader, {
+                children: header
+            }),
+            /*#__PURE__*/ jsx(SelectContent, {
+                "data-testid": listTestId,
+                tabIndex: -1,
+                "data-no-autofocus": "",
+                children: /*#__PURE__*/ jsx(TestIdProvider, {
+                    value: baseTestId,
+                    children: body
+                })
+            }),
+            footer
+        ]
+    });
+};
+FilterDropdownContent.displayName = 'FilterDropdownContent';
+export { FilterDropdownContent };

package/dist/components/FilterDropdown/FilterDropdownContext.d.ts

@@ -0,0 +1,60 @@
+import { type RefObject } from 'react';
+import type { CollectionItem, ListCollection } from '@ark-ui/react/collection';
+import type { FilterDropdownSpecialItem } from './lib';
+export interface FilterDropdownContextValue {
+    /** Attribute name: trigger text in multi, aria labels, «Clear {label}». */
+    label: string;
+    /** Single mode: trigger text while unset and the default «All» option text. */
+    allLabel: string;
+    multiple: boolean;
+    disabled: boolean;
+    /** The consumer value (base values only, `[]` = unset). */
+    value: string[];
+    /** The consumer's collection, unfiltered. */
+    collection: ListCollection<CollectionItem>;
+    /** The consumer's collection narrowed by the search query. */
+    filteredCollection: ListCollection<CollectionItem>;
+    /** `filteredCollection.group()` — groups with no matches are absent. */
+    groups: [string, CollectionItem[]][];
+    query: string;
+    setQuery: (query: string) => void;
+    /** The search field is shown: the collection has at least `searchThreshold` items. */
+    isSearchable: boolean;
+    /** A non-empty query is narrowing the list. */
+    isSearchActive: boolean;
+    /** Single mode and no query: «All» is part of the list. */
+    showAll: boolean;
+    allItem: FilterDropdownSpecialItem;
+    /**
+     * Multi mode, `selectedOnTop`, searchable, no query and something was picked when the menu
+     * opened.
+     */
+    showSelected: boolean;
+    /** Alias rows of the "Selected" snapshot, in pick order. */
+    aliasItems: FilterDropdownSpecialItem[];
+    clear: () => void;
+    triggerRef: RefObject<HTMLButtonElement | null>;
+    contentRef: RefObject<HTMLDivElement | null>;
+    /** Width the menu is pinned to while a query is active, so it does not jump as rows drop. */
+    lockedWidth: number | undefined;
+}
+export declare const FilterDropdownContext: import("react").Context<FilterDropdownContextValue | null>;
+export declare const useFilterDropdownContext: () => FilterDropdownContextValue;
+/** Set by `FilterDropdownSelected` around each of its rows: the alias that row stands for. */
+export declare const FilterDropdownAliasContext: import("react").Context<FilterDropdownSpecialItem<any> | null>;
+export interface UseFilterDropdownResult<T extends CollectionItem = CollectionItem> {
+    /** The collection narrowed by the current query (the whole collection when it is empty). */
+    filteredCollection: ListCollection<T>;
+    /** `filteredCollection.group()`; render these so the list follows the search. */
+    groups: [string, T[]][];
+    query: string;
+    isSearchActive: boolean;
+    multiple: boolean;
+    value: string[];
+    clear: () => void;
+}
+/**
+ * Reads the state of the surrounding `FilterDropdown` — chiefly the filtered items and groups
+ * to render inside `FilterDropdownContent`.
+ */
+export declare const useFilterDropdown: <T extends CollectionItem = CollectionItem>() => UseFilterDropdownResult<T>;

package/dist/components/FilterDropdown/FilterDropdownContext.js

@@ -0,0 +1,21 @@
+import { createContext, useContext } from "react";
+const FilterDropdownContext = /*#__PURE__*/ createContext(null);
+const useFilterDropdownContext = ()=>{
+    const context = useContext(FilterDropdownContext);
+    if (!context) throw new Error('FilterDropdown parts must be rendered inside <FilterDropdown>');
+    return context;
+};
+const FilterDropdownAliasContext = /*#__PURE__*/ createContext(null);
+const useFilterDropdown = ()=>{
+    const { filteredCollection, groups, query, isSearchActive, multiple, value, clear } = useFilterDropdownContext();
+    return {
+        filteredCollection: filteredCollection,
+        groups: groups,
+        query,
+        isSearchActive,
+        multiple,
+        value,
+        clear
+    };
+};
+export { FilterDropdownAliasContext, FilterDropdownContext, useFilterDropdown, useFilterDropdownContext };

package/dist/components/FilterDropdown/FilterDropdownEmpty.d.ts

@@ -0,0 +1,9 @@
+import type { FC, HTMLAttributes, ReactNode, Ref } from 'react';
+import { type TestableProps } from '../../utils/testId';
+export interface FilterDropdownEmptyProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'>, TestableProps {
+    ref?: Ref<HTMLDivElement>;
+    /** @default 'Nothing matches' */
+    children?: ReactNode;
+}
+/** Shown in place of the options when the query matches none of them. */
+export declare const FilterDropdownEmpty: FC<FilterDropdownEmptyProps>;

package/dist/components/FilterDropdown/FilterDropdownEmpty.js

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import { useTestId } from "../../utils/testId.js";
+import { SelectEmptyState } from "../Select/SelectEmptyState.js";
+import { useFilterDropdownContext } from "./FilterDropdownContext.js";
+const FilterDropdownEmpty = ({ ref, children, 'data-testid': testIdProp, ...props })=>{
+    const { filteredCollection } = useFilterDropdownContext();
+    const testId = useTestId('empty', testIdProp);
+    if (filteredCollection.size > 0) return null;
+    return /*#__PURE__*/ jsx("div", {
+        ...props,
+        ref: ref,
+        "data-slot": "filter-dropdown-empty",
+        "data-testid": testId,
+        children: /*#__PURE__*/ jsx(SelectEmptyState, {
+            className: "w-full max-w-240",
+            description: children ?? 'Nothing matches'
+        })
+    });
+};
+FilterDropdownEmpty.displayName = 'FilterDropdownEmpty';
+export { FilterDropdownEmpty };

package/dist/components/FilterDropdown/FilterDropdownFooter.d.ts

@@ -0,0 +1,9 @@
+import type { FC } from 'react';
+import { type TestableProps } from '../../utils/testId';
+import { type SelectFooterProps } from '../Select/SelectFooter';
+export type FilterDropdownFooterProps = Omit<SelectFooterProps, 'variant' | 'data-testid'> & TestableProps;
+/**
+ * Footer pinned under the list. Multi mode only, and only while something is picked; its default
+ * content is `FilterDropdownFooterClear`.
+ */
+export declare const FilterDropdownFooter: FC<FilterDropdownFooterProps>;

package/dist/components/FilterDropdown/FilterDropdownFooter.js

@@ -0,0 +1,19 @@
+import { jsx } from "react/jsx-runtime";
+import { useTestId } from "../../utils/testId.js";
+import { SelectFooter } from "../Select/SelectFooter.js";
+import { useFilterDropdownContext } from "./FilterDropdownContext.js";
+import { FilterDropdownFooterClear } from "./FilterDropdownFooterClear.js";
+const FilterDropdownFooter = ({ children, 'data-testid': testIdProp, ...props })=>{
+    const { multiple, value } = useFilterDropdownContext();
+    const testId = useTestId('footer', testIdProp);
+    if (!multiple || 0 === value.length) return null;
+    return /*#__PURE__*/ jsx(SelectFooter, {
+        ...props,
+        variant: "actions",
+        "data-slot": "filter-dropdown-footer",
+        "data-testid": testId,
+        children: children ?? /*#__PURE__*/ jsx(FilterDropdownFooterClear, {})
+    });
+};
+FilterDropdownFooter.displayName = 'FilterDropdownFooter';
+export { FilterDropdownFooter };

package/dist/components/FilterDropdown/FilterDropdownFooterClear.d.ts

@@ -0,0 +1,9 @@
+import type { FC } from 'react';
+import { type TestableProps } from '../../utils/testId';
+import { type ButtonProps } from '../Button';
+export type FilterDropdownFooterClearProps = Omit<ButtonProps<'button'>, 'variant' | 'color' | 'size' | 'as' | 'asChild'> & TestableProps;
+/**
+ * The «Clear» button of the multi-mode footer. Keeps the menu open and moves focus back into it
+ * (the search, or the list) before the footer disappears.
+ */
+export declare const FilterDropdownFooterClear: FC<FilterDropdownFooterClearProps>;

package/dist/components/FilterDropdown/FilterDropdownFooterClear.js

@@ -0,0 +1,40 @@
+import { jsx } from "react/jsx-runtime";
+import { useTestId } from "../../utils/testId.js";
+import { Button } from "../Button/index.js";
+import { useFilterDropdownContext } from "./FilterDropdownContext.js";
+const BUTTON_OWNED_KEYS = new Set([
+    'Enter',
+    ' '
+]);
+const FilterDropdownFooterClear = ({ children, onClick, onKeyDown, 'data-testid': testIdProp, ...props })=>{
+    const { clear } = useFilterDropdownContext();
+    const testId = useTestId('footer-clear', testIdProp);
+    const handleKeyDown = (event)=>{
+        onKeyDown?.(event);
+        if (BUTTON_OWNED_KEYS.has(event.key)) event.stopPropagation();
+    };
+    const handleClick = (event)=>{
+        onClick?.(event);
+        if (event.defaultPrevented) return;
+        const content = event.currentTarget.closest('[data-scope="select"][data-part="content"]');
+        const search = content?.querySelector('[data-slot="filter-dropdown-search"] input');
+        (search ?? content)?.focus({
+            preventScroll: true
+        });
+        clear();
+    };
+    return /*#__PURE__*/ jsx(Button, {
+        ...props,
+        "data-slot": "filter-dropdown-footer-clear",
+        "data-testid": testId,
+        "data-no-autofocus": "",
+        variant: "ghost",
+        color: "neutral",
+        size: "small",
+        onClick: handleClick,
+        onKeyDown: handleKeyDown,
+        children: children ?? 'Clear'
+    });
+};
+FilterDropdownFooterClear.displayName = 'FilterDropdownFooterClear';
+export { FilterDropdownFooterClear };

package/dist/components/FilterDropdown/FilterDropdownGroup.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentProps, FC } from 'react';
+import { SelectGroup } from '../Select/SelectGroup';
+export type FilterDropdownGroupProps = ComponentProps<typeof SelectGroup>;
+/** A labelled run of options. Render one per entry of `useFilterDropdown().groups`. */
+export declare const FilterDropdownGroup: FC<FilterDropdownGroupProps>;

package/dist/components/FilterDropdown/FilterDropdownGroup.js

@@ -0,0 +1,8 @@
+import { jsx } from "react/jsx-runtime";
+import { SelectGroup } from "../Select/SelectGroup.js";
+const FilterDropdownGroup = (props)=>/*#__PURE__*/ jsx(SelectGroup, {
+        ...props,
+        "data-slot": "filter-dropdown-group"
+    });
+FilterDropdownGroup.displayName = 'FilterDropdownGroup';
+export { FilterDropdownGroup };

package/dist/components/FilterDropdown/FilterDropdownGroupLabel.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentProps, FC } from 'react';
+import { SelectGroupLabel } from '../Select/SelectGroupLabel';
+export type FilterDropdownGroupLabelProps = ComponentProps<typeof SelectGroupLabel>;
+export declare const FilterDropdownGroupLabel: FC<FilterDropdownGroupLabelProps>;

package/dist/components/FilterDropdown/FilterDropdownGroupLabel.js

@@ -0,0 +1,8 @@
+import { jsx } from "react/jsx-runtime";
+import { SelectGroupLabel } from "../Select/SelectGroupLabel.js";
+const FilterDropdownGroupLabel = (props)=>/*#__PURE__*/ jsx(SelectGroupLabel, {
+        ...props,
+        "data-slot": "filter-dropdown-group-label"
+    });
+FilterDropdownGroupLabel.displayName = 'FilterDropdownGroupLabel';
+export { FilterDropdownGroupLabel };

package/dist/components/FilterDropdown/FilterDropdownOption.d.ts

@@ -0,0 +1,15 @@
+import { type ComponentProps, type ReactNode, type Ref } from 'react';
+import type { CollectionItem } from '@ark-ui/react/collection';
+import { SelectOption } from '../Select/SelectOption';
+export interface FilterDropdownOptionProps<T extends CollectionItem = CollectionItem> extends Omit<ComponentProps<typeof SelectOption>, 'item' | 'children'> {
+    ref?: Ref<HTMLDivElement>;
+    item: T;
+    /** Secondary text at the right end of the row, such as a count. */
+    hint?: ReactNode;
+    /** Row text. Defaults to the item's label from the collection. */
+    children?: ReactNode;
+}
+export declare function FilterDropdownOption<T extends CollectionItem>({ item, hint, children, 'data-testid': testIdProp, ...props }: FilterDropdownOptionProps<T>): import("react").JSX.Element;
+export declare namespace FilterDropdownOption {
+    var displayName: string;
+}

package/dist/components/FilterDropdown/FilterDropdownOption.js

@@ -0,0 +1,32 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { useTestId } from "../../utils/testId.js";
+import { SelectOption } from "../Select/SelectOption.js";
+import { SelectOptionHint } from "../Select/SelectOptionHint.js";
+import { SelectOptionIndicator } from "../Select/SelectOptionIndicator.js";
+import { SelectOptionText } from "../Select/SelectOptionText.js";
+import { FilterDropdownAliasContext, useFilterDropdownContext } from "./FilterDropdownContext.js";
+const FilterDropdownOption = ({ item, hint, children, 'data-testid': testIdProp, ...props })=>{
+    const { collection } = useFilterDropdownContext();
+    const alias = useContext(FilterDropdownAliasContext);
+    const value = collection.getItemValue(item);
+    const isCopy = alias?.source !== void 0 && collection.getItemValue(alias.source) === value;
+    const copyTestId = useTestId('selected-option');
+    return /*#__PURE__*/ jsxs(SelectOption, {
+        ...props,
+        item: isCopy && alias ? alias : item,
+        "data-slot": "filter-dropdown-option",
+        "data-testid": testIdProp ?? (isCopy ? copyTestId : void 0),
+        children: [
+            /*#__PURE__*/ jsx(SelectOptionText, {
+                children: children ?? collection.stringifyItem(item)
+            }),
+            null != hint && /*#__PURE__*/ jsx(SelectOptionHint, {
+                children: hint
+            }),
+            /*#__PURE__*/ jsx(SelectOptionIndicator, {})
+        ]
+    });
+};
+FilterDropdownOption.displayName = 'FilterDropdownOption';
+export { FilterDropdownOption };

package/dist/components/FilterDropdown/FilterDropdownSearch.d.ts

@@ -0,0 +1,12 @@
+import type { FC } from 'react';
+import { type TestableProps } from '../../utils/testId';
+import { type SelectSearchInputProps } from '../Select/SelectSearchInput';
+export interface FilterDropdownSearchProps extends Omit<SelectSearchInputProps, 'value' | 'onChange' | 'data-testid'>, TestableProps {
+    /** Called after the query changes; the root owns the query itself. */
+    onChange?: (query: string) => void;
+}
+/**
+ * The search field pinned above the list. Renders only once the collection reaches
+ * `searchThreshold` items, and takes focus when the menu opens. Attributes land on the `<input>`.
+ */
+export declare const FilterDropdownSearch: FC<FilterDropdownSearchProps>;

package/dist/components/FilterDropdown/FilterDropdownSearch.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import { useSelectContext } from "@ark-ui/react/select";
+import { useTestId } from "../../utils/testId.js";
+import { SelectSearchInput } from "../Select/SelectSearchInput.js";
+import { useFilterDropdownContext } from "./FilterDropdownContext.js";
+const FilterDropdownSearch = ({ onChange, 'aria-label': ariaLabel, 'data-testid': testIdProp, ...props })=>{
+    const { label, query, setQuery, isSearchable } = useFilterDropdownContext();
+    const testId = useTestId('search', testIdProp);
+    const select = useSelectContext();
+    if (!isSearchable) return null;
+    const handleChange = (next)=>{
+        setQuery(next);
+        onChange?.(next);
+    };
+    const highlighted = select.highlightedItem;
+    const activeDescendant = highlighted ? select.getItemProps({
+        item: highlighted
+    }).id : void 0;
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "filter-dropdown-search",
+        className: "-mb-3",
+        children: /*#__PURE__*/ jsx(SelectSearchInput, {
+            "data-autofocus": "",
+            role: "combobox",
+            "aria-autocomplete": "list",
+            "aria-expanded": select.open,
+            "aria-controls": select.getContentProps().id,
+            "aria-activedescendant": activeDescendant,
+            ...props,
+            "aria-label": ariaLabel ?? `Search ${label}`,
+            value: query,
+            onChange: handleChange,
+            "data-testid": testId
+        })
+    });
+};
+FilterDropdownSearch.displayName = 'FilterDropdownSearch';
+export { FilterDropdownSearch };

package/dist/components/FilterDropdown/FilterDropdownSelected.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentProps, ReactNode } from 'react';
+import type { CollectionItem } from '@ark-ui/react/collection';
+import { SelectGroup } from '../Select/SelectGroup';
+export interface FilterDropdownSelectedProps<T extends CollectionItem = CollectionItem> extends Omit<ComponentProps<typeof SelectGroup>, 'children'> {
+    /** @default 'Selected' */
+    label?: ReactNode;
+    /**
+     * Renders one row; return the same `FilterDropdownOption` as in the list (hint included) and it
+     * becomes this row's copy. Defaults to a plain option with the item's label.
+     */
+    children?: (item: T) => ReactNode;
+}
+export declare function FilterDropdownSelected<T extends CollectionItem>({ label, children, 'data-testid': testIdProp, ...props }: FilterDropdownSelectedProps<T>): import("react").JSX.Element | null;
+export declare namespace FilterDropdownSelected {
+    var displayName: string;
+}

package/dist/components/FilterDropdown/FilterDropdownSelected.js

@@ -0,0 +1,38 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useTestId } from "../../utils/testId.js";
+import { SelectGroup } from "../Select/SelectGroup.js";
+import { SelectGroupLabel } from "../Select/SelectGroupLabel.js";
+import { SelectSeparator } from "../Select/SelectSeparator.js";
+import { FilterDropdownAliasContext, useFilterDropdownContext } from "./FilterDropdownContext.js";
+import { FilterDropdownOption } from "./FilterDropdownOption.js";
+const FilterDropdownSelected = ({ label = 'Selected', children, 'data-testid': testIdProp, ...props })=>{
+    const { showSelected, aliasItems } = useFilterDropdownContext();
+    const testId = useTestId('selected', testIdProp);
+    if (!showSelected) return null;
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsxs(SelectGroup, {
+                ...props,
+                "data-slot": "filter-dropdown-selected",
+                "data-testid": testId,
+                children: [
+                    /*#__PURE__*/ jsx(SelectGroupLabel, {
+                        children: label
+                    }),
+                    aliasItems.map((alias)=>{
+                        const source = alias.source;
+                        return /*#__PURE__*/ jsx(FilterDropdownAliasContext.Provider, {
+                            value: alias,
+                            children: children ? children(source) : /*#__PURE__*/ jsx(FilterDropdownOption, {
+                                item: source
+                            })
+                        }, alias.value);
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(SelectSeparator, {})
+        ]
+    });
+};
+FilterDropdownSelected.displayName = 'FilterDropdownSelected';
+export { FilterDropdownSelected };

package/dist/components/FilterDropdown/FilterDropdownTrigger.d.ts

@@ -0,0 +1,16 @@
+import { type ButtonHTMLAttributes, type FC, type ReactNode, type Ref } from 'react';
+import { type TestableProps } from '../../utils/testId';
+export interface FilterDropdownTriggerProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'>, TestableProps {
+    ref?: Ref<HTMLButtonElement>;
+    /**
+     * Only a `<FilterDropdownClear />`, to replace the ✕ rendered in multi mode. The label is
+     * derived from the value and is not overridable.
+     */
+    children?: ReactNode;
+}
+/**
+ * The 36px trigger. Dashed while unset, solid once set; reads «All …» / the value in single mode
+ * and «Name», «Name • value» or «Name • N» in multi mode. In multi mode Backspace/Delete on the
+ * focused trigger clears the filter.
+ */
+export declare const FilterDropdownTrigger: FC<FilterDropdownTriggerProps>;