@moneyforward/mfui-components 2.48.2 → 3.1.0

package/dist/esm/src/SelectBox/SelectBox.types.d.ts

@@ -1,358 +0,0 @@
-import { type ComponentPropsWithoutRef } from 'react';
-import { type VirtualizerOptions } from '@tanstack/react-virtual';
-import { type SelectBoxSlotRecipeVariant } from '../../styled-system/recipes';
-import { type SearchBoxProps } from '../SearchBox';
-import { type PopoverProps } from '../Popover';
-type AllowedValueTypes = string | number | undefined;
-export type VirtualOptionTypes = Pick<VirtualizerOptions<HTMLElement, Element>, 'estimateSize' | 'overscan'>;
-export type BasedAdditionalProps = Record<string, unknown>;
-export type SelectBoxOption<T extends AllowedValueTypes = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps> = ({
-    /**
-     * The label to be displayed in the list.
-     *
-     * This would be the group label of the nested list when options prop is provided.
-     */
-    label: string;
-    /**
-     * This must be omitted when the options prop is provided.
-     */
-    value?: never;
-    /**
-     * The options to be nested under the group label.
-     */
-    options?: SelectBoxOption<T, AdditionalProps>[];
-} & AdditionalProps) | ({
-    /**
-     * The label to be displayed in the list.
-     */
-    label: string;
-    /**
-     * The value to be returned when the option is selected.
-     *
-     * This must be unique for each option since it's used to identify the option in the list.
-     */
-    value?: T;
-    /**
-     * This must be omitted when the value prop is provided.
-     */
-    options?: never;
-    /**
-     * Whether this option is disabled.
-     */
-    disabled?: boolean;
-} & AdditionalProps);
-/**
- * A flattened option type representing an individual selectable option (not a group).
- * Used for keyboard navigation and virtualization.
- */
-export type FlatOption<T extends AllowedValueTypes = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps> = Extract<SelectBoxOption<T, AdditionalProps>, {
-    value?: T;
-}>;
-export type SelectBoxProps<T extends AllowedValueTypes = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps> = {
-    /**
-     * The id of this component.
-     * This prop is used to relate the component to the corresponding label.
-     *
-     * @example
-     * ```tsx
-     * <label htmlFor="select-box-label">Label</label>
-     * <SelectBox id="select-box-label" />
-     * ```
-     */
-    id?: string;
-    /**
-     * Configuration for automatically scrolling to the selected option when opening the dropdown.
-     * When set to false or undefined, no auto-scrolling occurs.
-     * When set to true, uses default settings (smooth behavior, center alignment).
-     * When an object is provided, allows customizing the scroll behavior.
-     *
-     * Please note that enabling this feature will make force the whole page to be scrolled to the selected option.
-     *
-     * @example
-     * ```tsx
-     * // Default smooth scroll to center
-     * <SelectBox enableAutoScrollToSelectedOption={true} />
-     *
-     * // Custom scroll behavior
-     * <SelectBox enableAutoScrollToSelectedOption={{ behavior: 'auto', block: 'nearest' }} />
-     * ```
-     */
-    enableAutoScrollToSelectedOption?: boolean | ScrollIntoViewOptions;
-    /**
-     * The properties for the popover content panel.
-     *
-     * @property className - The class name of the popover content panel.
-     *
-     * @property minWidth - The minimum width of the popover content panel.
-     *
-     * @property allowedPlacements - Allowed placements for the popover relative to the trigger element.
-     */
-    popoverContentProps?: Pick<ComponentPropsWithoutRef<'div'>, 'className'> & {
-        minWidth?: PopoverProps['minWidth'];
-        allowedPlacements?: PopoverProps['allowedPlacements'];
-    };
-    /**
-     * The properties for the popover wrapper element.
-     *
-     * @property maxHeight - The maximum height of the popover wrapper element.
-     */
-    popoverWrapperProps?: {
-        maxHeight?: PopoverProps['maxHeight'];
-    };
-    /**
-     * The properties for the trigger element.
-     *
-     * @property aria-label - The alternative text for the trigger element.
-     *
-     * @property className - The class name of the trigger element.
-     */
-    triggerProps?: Pick<ComponentPropsWithoutRef<'button'>, 'aria-label' | 'className'>;
-    /**
-     * Whether you let user to clear the content or not.
-     * This will add the Clear button if current SelectBox has value.
-     *
-     * @default false
-     */
-    enableClearButton?: boolean;
-    /**
-     * The properties for the clear button.
-     * If this prop is not passed, the default values for each property will be applied.
-     *
-     * @property aria-label - The alternative text for the clear button. Default is '値をクリアする'.
-     *
-     * @default undefined
-     */
-    clearButtonProps?: Pick<ComponentPropsWithoutRef<'button'>, 'aria-label'>;
-    /**
-     * The size of the SelectBox component.
-     */
-    size?: SelectBoxSlotRecipeVariant['size'];
-    /**
-     * The selectable options for the list
-     *
-     * It should be an array of objects with `label` and `value` properties.
-     *
-     * **Tip**: Use `satisfies` for automatic type inference when using additional properties:
-     * ```tsx
-     * const options = [...] satisfies SelectBoxOption<string, YourType>[];
-     * <SelectBox options={options} /> // Type inference works automatically!
-     * ```
-     */
-    options?: SelectBoxOption<T, AdditionalProps>[];
-    /**
-     * Pass the initial selected option value.
-     * Use this prop when you want an uncontrolled component.
-     *
-     * Can be either:
-     * - A primitive value (string/number) that matches an option's value
-     * - A SelectBoxOption object with both label and value (useful for async scenarios)
-     */
-    defaultValue?: SelectBoxOption<T, AdditionalProps>['value'] | SelectBoxOption<T, AdditionalProps>;
-    /**
-     * Pass the currently selected option value.
-     * Use this prop when you want a controlled component.
-     * Should use this prop with "onChange" prop to control the selected option.
-     *
-     * Can be either:
-     * - A primitive value (string/number) that matches an option's value
-     * - A SelectBoxOption object with both label and value (useful for async scenarios)
-     */
-    value?: SelectBoxOption<T, AdditionalProps>['value'] | SelectBoxOption<T, AdditionalProps>;
-    /**
-     * Text to be displayed when options are not selected.
-     * If you want to show placeholder even if using `renderDisplayValue`, please render placeholder in `renderDisplayValue` function.
-     */
-    placeholder?: string;
-    /**
-     * The message to be displayed in the listbox when the options are empty.
-     */
-    emptyMessage?: string;
-    /**
-     * Whether the trigger is disabled.
-     */
-    disabled?: boolean;
-    /**
-     * Whether the trigger is invalid.
-     */
-    invalid?: boolean;
-    /**
-     * Whether the popover width should be constrained to match the trigger element width.
-     *
-     * When enabled, the popover will have the same width as the trigger element,
-     * preventing it from expanding beyond the trigger boundaries even if option
-     * labels are longer. This is useful for maintaining consistent visual alignment
-     * in forms and handling very long option text.
-     *
-     * @default false
-     */
-    enableConstrainedPopoverWidth?: boolean;
-    /**
-     * The DOM node where the dropdown menu should be rendered.
-     *
-     * If provided, the menu is rendered inside this node. Otherwise, a suitable
-     * DOM node is chosen automatically.
-     */
-    targetDOMNode?: HTMLElement | null;
-    /**
-     * The name of the input element.
-     *
-     * It's used to identify the input element in the form.
-     */
-    name?: string;
-    /**
-     * The callback function that is called when the selected option is changed.
-     *
-     * @param value - The value of the selected option
-     *
-     * @param option - The full option object that was selected (includes additional properties if defined)
-     *
-     * @example
-     * ```tsx
-     * <SelectBox
-     *   onChange={(value, option) => {
-     *     console.log('Selected value:', value);
-     *     console.log('Full option:', option); // Access additional option properties
-     *   }}
-     * />
-     * ```
-     */
-    onChange?: (value: SelectBoxOption<T, AdditionalProps>['value'], option: SelectBoxOption<T, AdditionalProps> | null) => void;
-    /**
-     * The callback function that is called when the SelectBox loses focus.
-     * This will only fire when the user truly leaves the component (not when the popover opens).
-     *
-     * @param event - The blur event from the trigger element
-     *
-     * @example
-     * ```tsx
-     * <SelectBox
-     *   onBlur={(event) => {
-     *     console.log('SelectBox lost focus');
-     *     // Perform validation or other actions
-     *   }}
-     * />
-     * ```
-     */
-    onBlur?: (event: React.FocusEvent<HTMLElement>) => void;
-    /**
-     * The function to customize what displays inside the trigger button.
-     * - Return only elements that are allowed to be contained inside the `<button>` element.
-     * - When the `placeholder` prop is set and no option is selected, the `placeholder` is prioritized over the `renderDisplayValue` prop.
-     */
-    renderDisplayValue?: (selectedOption: SelectBoxOption<T, AdditionalProps> | null) => React.ReactNode;
-    /**
-     * The function to customize how the options are rendered in the list.
-     *
-     * @param option - The option object being rendered (includes additional properties if defined)
-     *
-     * @param isSelected - Whether the option is currently selected
-     *
-     * @example
-     * ```tsx
-     * // Access additional properties in renderOption
-     * const options = [
-     *   { label: 'A', value: '1', customProp: 'foo' }
-     * ] satisfies SelectBoxOption<string, { customProp: string }>[];
-     *
-     * <SelectBox
-     *   options={options}
-     *   renderOption={(option, isSelected) => (
-     *     <div>{option.label} - {option.customProp}</div>
-     *   )}
-     * />
-     * ```
-     */
-    renderOption?: (option: SelectBoxOption<T, AdditionalProps>, isSelected: boolean) => React.ReactNode;
-    /**
-     * The function to customize how the popover is rendered.
-     * - `searchNode` is the search input element. It's available only when `enableSearchOptions` is `true`.
-     * - `optionsNode` is the list of options.
-     */
-    renderPopoverContent?: (nodes: {
-        optionsNode: React.ReactNode;
-        searchNode: React.ReactNode | null;
-    }) => React.ReactNode;
-    /**
-     * The flag to enable search functionality
-     */
-    enableSearchOptions?: boolean;
-    /**
-     * The message to be displayed when the options are not found.
-     */
-    notFoundMessage?: string;
-    /**
-     * The properties for the SearchBox component.
-     */
-    searchBoxProps?: Pick<SearchBoxProps, 'clearButtonProps' | 'placeholder'>;
-    /**
-     * Flag to indicate loading state of the options.
-     * When true, the SelectBox will display skeleton placeholders
-     * in the options list.
-     */
-    loading?: boolean;
-    /**
-     * Handler executed when text is entered in the search box.
-     * The handler is debounced by 300ms.
-     *
-     * When this prop is provided, client-side filtering is disabled as it's
-     * assumed that filtering will be handled by the prop.
-     */
-    onSearchOptions?: (text: string) => void;
-    /**
-     * Callback fired when the open state of the SelectBox changes.
-     *
-     * @param open - The new open state of the SelectBox.
-     */
-    onOpenStateChanged?: (open: boolean) => void;
-    /**
-     * Flag to show a divider between group options in the list.
-     * When true, a divider is shown between group options except the first one.
-     *
-     * @default false
-     */
-    showGroupOptionDivider?: boolean;
-    /**
-     * The properties for the trigger wrapper element.
-     *
-     * @property className - The class name of the trigger wrapper div.
-     */
-    triggerWrapperProps?: Pick<ComponentPropsWithoutRef<'div'>, 'className'>;
-    /**
-     * Enable auto unmounting of the popover content when it's not displayed.
-     * When true, the popover content will return null instead of hiding via CSS.
-     *
-     * @default true
-     */
-    enableAutoUnmount?: boolean;
-    /**
-     * Enable virtualization for large option lists.
-     * When enabled, only visible options are rendered to improve performance.
-     *
-     * Recommended for lists with 100+ options.
-     *
-     * @default false
-     *
-     * @example
-     * ```tsx
-     * <SelectBox options={largeList} enableVirtualization />
-     * ```
-     */
-    enableVirtualization?: boolean;
-    /**
-     * Configuration for virtualization behavior.
-     * Only applies when `enableVirtualization` is true.
-     *
-     * @example
-     * ```tsx
-     * <SelectBox
-     *   enableVirtualization
-     *   virtualizationOptions={{
-     *     estimateSize: (index) => 48, // Function returning size in pixels
-     *     overscan: 10                 // Number of items outside visible area
-     *   }}
-     * />
-     * ```
-     */
-    virtualizationOptions?: VirtualOptionTypes;
-};
-export {};

package/dist/esm/src/SelectBox/SelectBoxOption.d.ts

@@ -1,46 +0,0 @@
-import React from 'react';
-import { type BasedAdditionalProps, type SelectBoxOption } from './SelectBox.types';
-type SelectBoxOptionProps<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps> = {
-    /**
-     * The option data to render.
-     */
-    option: SelectBoxOption<T, AdditionalProps>;
-    /**
-     * Whether this option is currently selected.
-     */
-    isSelected: boolean;
-    /**
-     * Index of the currently tabbable option.
-     */
-    tabbableOptionIndex: number;
-    /**
-     * Index of this option in the flat options array.
-     */
-    optionIndex: number;
-    /**
-     * CSS classes from the parent component.
-     */
-    classes: {
-        listItem: string;
-    };
-    /**
-     * Custom render function for the option.
-     */
-    renderOption?: (option: SelectBoxOption<T, AdditionalProps>, isSelected: boolean) => React.ReactNode;
-    /**
-     * Handler called when option receives focus.
-     */
-    onFocus: (optionIndex: number) => void;
-    /**
-     * Handler called when option is clicked.
-     */
-    onClick: (option: SelectBoxOption<T, AdditionalProps>) => void;
-    /**
-     * Handler for keyboard events.
-     */
-    onKeyDown: (event: React.KeyboardEvent<HTMLLIElement>) => void;
-};
-export declare const SelectBoxOptionComponent: (<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>(props: SelectBoxOptionProps<T, AdditionalProps>) => React.ReactElement) & {
-    displayName: string;
-};
-export {};

package/dist/esm/src/SelectBox/SelectBoxOptionGroup.d.ts

@@ -1,52 +0,0 @@
-import React from 'react';
-import { type BasedAdditionalProps, type SelectBoxOption } from './SelectBox.types';
-type SelectBoxOptionGroupProps<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps> = {
-    /**
-     * The group option with nested options.
-     */
-    groupOption: SelectBoxOption<T, AdditionalProps> & {
-        options: (SelectBoxOption<T, AdditionalProps> | null | undefined)[];
-    };
-    /**
-     * Currently selected option.
-     */
-    selectedOption: SelectBoxOption<T, AdditionalProps> | null;
-    /**
-     * Map from option value to its index in flatOptions for O(1) lookup.
-     */
-    valueToIndexMap: Map<string | number, number>;
-    /**
-     * Index of the currently tabbable option.
-     */
-    tabbableOptionIndex: number;
-    /**
-     * CSS classes from the parent component.
-     */
-    classes: {
-        listItem: string;
-    };
-    /**
-     * Custom render function for options.
-     */
-    renderOption?: (option: SelectBoxOption<T, AdditionalProps>, isSelected: boolean) => React.ReactNode;
-    /**
-     * Handler called when option receives focus.
-     */
-    onOptionFocus: (optionIndex: number) => void;
-    /**
-     * Handler called when option is clicked.
-     */
-    onOptionClick: (option: SelectBoxOption<T, AdditionalProps>) => void;
-    /**
-     * Handler for keyboard events on options.
-     */
-    onOptionKeyDown: (option: SelectBoxOption<T, AdditionalProps>) => (event: React.KeyboardEvent<HTMLLIElement>) => void;
-    /**
-     * Utility to find index in flatOptions by value.
-     */
-    findFlatOptionIndexByValue: (valueToIndexMap: Map<string | number, number>, option: SelectBoxOption<T, AdditionalProps>) => number;
-};
-export declare const SelectBoxOptionGroup: (<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>(props: SelectBoxOptionGroupProps<T, AdditionalProps>) => React.ReactElement) & {
-    displayName: string;
-};
-export {};

package/dist/esm/src/SelectBox/hooks/useKeyboardNavigation.d.ts

@@ -1,77 +0,0 @@
-import { type KeyboardEventHandler } from 'react';
-import { type BasedAdditionalProps, type SelectBoxOption } from '../SelectBox.types';
-type UseKeyboardNavigationProps<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps> = {
-    /**
-     * Whether the option panel is currently open.
-     */
-    isOptionPanelOpen: boolean;
-    /**
-     * Whether the component is in loading state.
-     */
-    loading: boolean;
-    /**
-     * Whether search functionality is enabled.
-     */
-    enableSearchOptions: boolean;
-    /**
-     * Currently selected option.
-     */
-    localSelectedOption: SelectBoxOption<T, AdditionalProps> | null;
-    /**
-     * Flat array of all selectable options.
-     */
-    flatOptions: SelectBoxOption<T, AdditionalProps>[];
-    /**
-     * Filtered options (after search and other filters).
-     */
-    filteredOptions: (SelectBoxOption<T, AdditionalProps> | null | undefined)[];
-    /**
-     * Auto-scroll configuration for selected options.
-     */
-    enableAutoScrollToSelectedOption?: boolean | ScrollIntoViewOptions;
-    /**
-     * Callback when an option is selected.
-     */
-    onSelectOption: (option: SelectBoxOption<T, AdditionalProps>) => void;
-    /**
-     * Callback to close the option panel.
-     */
-    onCloseOptionPanel: () => void;
-    /**
-     * Reference to the option panel container.
-     */
-    optionPanelRef: React.RefObject<HTMLDivElement | null>;
-    /**
-     * Reference to the search input element.
-     */
-    searchInputRef: React.RefObject<HTMLInputElement | null>;
-    /**
-     * Scroll to a specific option index (for virtualization).
-     */
-    scrollToIndex?: (index: number, options?: {
-        align?: 'start' | 'center' | 'end' | 'auto';
-        behavior?: 'auto' | 'smooth';
-    }) => void;
-    /**
-     * Whether the option list is virtualized.
-     */
-    isVirtualized?: boolean;
-};
-/**
- * Hook to manage keyboard navigation and interaction for options in SelectBox
- *
- * This hook handles:
- * - Tracking which option should be tabbable
- * - Arrow key navigation between options
- * - Enter/Space key selection
- * - Escape key to close panel
- * - Focus management and auto-scrolling
- *
- * @returns Object with handlers and state for option keyboard navigation
- */
-export declare function useKeyboardNavigation<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>({ isOptionPanelOpen, loading, enableSearchOptions, localSelectedOption, flatOptions, filteredOptions, enableAutoScrollToSelectedOption, onSelectOption, onCloseOptionPanel, optionPanelRef, searchInputRef, scrollToIndex, isVirtualized, }: UseKeyboardNavigationProps<T, AdditionalProps>): {
-    tabbableOptionIndex: number;
-    handleOptionFocus: (optionIndex: number) => void;
-    createKeyDownHandler: (option: SelectBoxOption<T, AdditionalProps>) => KeyboardEventHandler<HTMLLIElement>;
-};
-export {};

package/dist/esm/src/SelectBox/hooks/useSearchBox.d.ts

@@ -1,28 +0,0 @@
-import { type BasedAdditionalProps, type SelectBoxOption } from '../SelectBox.types';
-/**
- * Custom hook to handle search functionality within a SelectBox component.
- *
- * @param options - Array of SelectBox options (can include nested group options).
- *
- * @param enableSearchOptions - Indicates if the SelectBox component is searchable.
- *
- * @param onSearchOptions - Handler executed when the search text changes. When
- * provided, client-side filtering is disabled as it's assumed that the caller
- * will handle the filtering.
- *
- * @returns Object containing the filtered options, search text, and handler to update search text.
- */
-export declare const useSearchBox: <T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>(options: (SelectBoxOption<T, AdditionalProps> | null | undefined)[], enableSearchOptions: boolean, onSearchOptions?: (text: string) => void) => {
-    /**
-     * Handler for search input change events.
-     */
-    onSearchTextChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
-    /**
-     * Filtered options based on search text (client-side filtering only when onSearchOptions is not provided).
-     */
-    filteredOptions: (SelectBoxOption<T, AdditionalProps> | null | undefined)[];
-    /**
-     * Current search text value.
-     */
-    searchText: string;
-};

package/dist/esm/src/SelectBox/hooks/useTypeAhead.d.ts

@@ -1,21 +0,0 @@
-import { type BasedAdditionalProps, type SelectBoxOption } from '../SelectBox.types';
-type UseTypeAheadProps<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps> = {
-    options: SelectBoxOption<T, AdditionalProps>[];
-    onSelectOption: (selectedOption: SelectBoxOption<T, AdditionalProps>, selectedIndex: number) => void;
-    /**
-     * Scroll to a specific option index (for virtualization).
-     */
-    scrollToIndex?: (index: number, options?: {
-        align?: 'start' | 'center' | 'end' | 'auto';
-        behavior?: 'auto' | 'smooth';
-    }) => void;
-    /**
-     * Whether the option list is virtualized.
-     */
-    isVirtualized?: boolean;
-};
-export declare const useTypeAhead: <T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>({ options, onSelectOption, scrollToIndex, isVirtualized, }: UseTypeAheadProps<T, AdditionalProps>) => {
-    handleTypeAhead: (event: KeyboardEvent) => void;
-    cleanup: () => void;
-};
-export {};

package/dist/esm/src/SelectBox/hooks/useVirtualizedOptions.d.ts

@@ -1,63 +0,0 @@
-import { useVirtualizer } from '@tanstack/react-virtual';
-import { type RefObject } from 'react';
-import { type BasedAdditionalProps, type FlatOption, type VirtualOptionTypes } from '../SelectBox.types';
-export type UseVirtualizedOptionsParams<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps> = {
-    /**
-     * Enable virtualization for the option list
-     */
-    enabled: boolean;
-    /**
-     * Reference to the scrollable parent element
-     */
-    parentRef: RefObject<HTMLElement | null>;
-    /**
-     * Flat array of all options
-     */
-    flatOptions: FlatOption<T, AdditionalProps>[];
-} & Partial<VirtualOptionTypes>;
-export type UseVirtualizedOptionsReturn = {
-    /**
-     * The virtualizer instance from @tanstack/react-virtual
-     * Null when virtualization is disabled
-     */
-    virtualizer: ReturnType<typeof useVirtualizer<HTMLElement, Element>> | null;
-    /**
-     * Array of virtual items to render (only visible + overscan items)
-     */
-    virtualItems: ReturnType<typeof useVirtualizer<HTMLElement, Element>>['getVirtualItems'] extends () => infer R ? R : never;
-    /**
-     * Total height of all items combined
-     */
-    totalSize: number;
-    /**
-     * Scroll to a specific option by index
-     */
-    scrollToIndex: (index: number, options?: {
-        align?: 'start' | 'center' | 'end' | 'auto';
-        behavior?: 'auto' | 'smooth';
-    }) => void;
-    /**
-     * Whether virtualization is currently enabled
-     */
-    isVirtualized: boolean;
-};
-/**
- * Custom hook for virtualizing large option lists using @tanstack/react-virtual.
- * Only renders visible items + overscan for improved performance.
- *
- * @param params - Virtualization configuration
- *
- * @returns Virtualizer instance and helper methods
- *
- * @example
- * ```tsx
- * const { virtualItems, totalSize, scrollToIndex, isVirtualized } = useVirtualizedOptions({
- *   enabled: true,
- *   parentRef: optionPanelRef,
- *   flatOptions,
- *   estimateSize: () => 36, // or (index) => index < 10 ? 40 : 36 for dynamic sizing
- *   overscan: 5,
- * });
- * ```
- */
-export declare function useVirtualizedOptions<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>({ enabled, parentRef, flatOptions, estimateSize, overscan, }: UseVirtualizedOptionsParams<T, AdditionalProps>): UseVirtualizedOptionsReturn;

package/dist/esm/src/SelectBox/index.d.ts

@@ -1,2 +0,0 @@
-export { SelectBox } from './SelectBox';
-export type { SelectBoxProps, SelectBoxOption } from './SelectBox.types';

package/dist/esm/src/SelectBox/utils/findFlatOptionIndexByValue.d.ts

@@ -1,18 +0,0 @@
-import { type BasedAdditionalProps, type SelectBoxOption } from '../SelectBox.types';
-/**
- * Builds a Map from option value to its index in flatOptions for O(1) lookup.
- *
- * @param flatOptions - The array of flat options to index.
- *
- * @returns Map of value to index.
- */
-export declare function buildValueToIndexMap<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>(flatOptions: SelectBoxOption<T, AdditionalProps>[]): Map<string | number, number>;
-/**
- * Finds the index of an option in flatOptions by matching the value property using a prebuilt map.
- * Returns -1 if not found or if the option has no value.
- *
- * @param valueToIndexMap - Map from value to index, built from flatOptions.
- *
- * @param option - The option whose value to match.
- */
-export declare function findFlatOptionIndexByValue<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>(valueToIndexMap: Map<string | number, number>, option: SelectBoxOption<T, AdditionalProps>): number;

package/dist/esm/src/SelectBox/utils/findOptionByValue.d.ts

@@ -1,11 +0,0 @@
-import { type BasedAdditionalProps, type SelectBoxOption } from '../SelectBox.types';
-/**
- * Finds an option in a (potentially) nested SelectBox options array by its value.
- *
- * @param options - The (possibly nested) options array to search in.
- *
- * @param value - The value to search for.
- *
- * @returns The found option or null if no option with the given value exists.
- */
-export declare function findOptionByValue<T extends string | number | undefined = string, AdditionalProps extends BasedAdditionalProps = BasedAdditionalProps>(options: (SelectBoxOption<T, AdditionalProps> | null | undefined)[], value: T | undefined): SelectBoxOption<T, AdditionalProps> | null;