react-select-async-paginate/dist/index.d.ts

Wrapper above react-select that supports pagination on menu scroll

import { Ref, ReactElement, ComponentType } from 'react';
import { GroupBase, Props, OptionsOrGroups, FilterOptionOption, InputActionMeta, SelectInstance, MenuListProps, SelectComponentsConfig } from 'react-select';

type RequestOptionsCallerType = "autoload" | "menu-toggle" | "input-change" | "menu-scroll";
type ReduceOptions<OptionType, Group extends GroupBase<OptionType>, Additional> = (prevOptions: OptionsOrGroups<OptionType, Group>, loadedOptions: OptionsOrGroups<OptionType, Group>, additional: Additional | undefined) => OptionsOrGroups<OptionType, Group>;
type OptionsCacheItem<OptionType, Group extends GroupBase<OptionType>, Additional> = {
    isFirstLoad: boolean;
    isLoading: boolean;
    lockedUntil: number;
    options: OptionsOrGroups<OptionType, Group>;
    hasMore: boolean;
    additional?: Additional;
};
type OptionsCache<OptionType, Group extends GroupBase<OptionType>, Additional> = {
    [key: string]: OptionsCacheItem<OptionType, Group, Additional>;
};
type ShouldLoadMore = (scrollHeight: number, clientHeight: number, scrollTop: number) => boolean;
type Response<OptionType, Group extends GroupBase<OptionType>, Additional> = {
    options: OptionsOrGroups<OptionType, Group>;
    hasMore?: boolean;
    additional?: Additional;
};
type LoadOptions<OptionType, Group extends GroupBase<OptionType>, Additional> = (inputValue: string, options: OptionsOrGroups<OptionType, Group>, additional?: Additional) => Response<OptionType, Group, Additional> | Promise<Response<OptionType, Group, Additional>>;
type FilterOption<OptionType> = ((option: FilterOptionOption<OptionType>, rawInput: string) => boolean) | null;
type UseAsyncPaginateBaseResult<OptionType, Group extends GroupBase<OptionType>> = {
    handleScrolledToBottom: () => void;
    shouldLoadMore: ShouldLoadMore;
    isLoading: boolean;
    isFirstLoad: boolean;
    options: OptionsOrGroups<OptionType, Group>;
    filterOption: FilterOption<OptionType>;
};
type UseAsyncPaginateResult<OptionType, Group extends GroupBase<OptionType>> = UseAsyncPaginateBaseResult<OptionType, Group> & {
    inputValue: string;
    menuIsOpen: boolean;
    onInputChange: (inputValue: string, actionMeta: InputActionMeta) => void;
    onMenuClose: () => void;
    onMenuOpen: () => void;
};
type UseAsyncPaginateParams<OptionType, Group extends GroupBase<OptionType>, Additional> = {
    /**
     * Clear all cached options on search change
     */
    clearCacheOnSearchChange?: boolean;
    /**
     * Clear all cached options on menu close
     */
    clearCacheOnMenuClose?: boolean;
    loadOptions: LoadOptions<OptionType, Group, Additional>;
    options?: OptionsOrGroups<OptionType, Group>;
    defaultOptions?: boolean | OptionsOrGroups<OptionType, Group>;
    additional?: Additional;
    defaultAdditional?: Additional;
    loadOptionsOnMenuOpen?: boolean;
    debounceTimeout?: number;
    reduceOptions?: ReduceOptions<OptionType, Group, Additional>;
    shouldLoadMore?: ShouldLoadMore;
    filterOption?: FilterOption<OptionType>;
    inputValue?: string;
    menuIsOpen?: boolean;
    defaultInputValue?: string;
    defaultMenuIsOpen?: boolean;
    /**
     * Post-mapping of loaded options to display them in the menu
     * @param options loaded options
     * @returns options to display in the menu
     */
    mapOptionsForMenu?: (options: OptionsOrGroups<OptionType, Group>) => OptionsOrGroups<OptionType, Group>;
    onInputChange?: (newValue: string, actionMeta: InputActionMeta) => void;
    onMenuClose?: () => void;
    onMenuOpen?: () => void;
    reloadOnErrorTimeout?: number;
};
type UseAsyncPaginateBaseParams<OptionType, Group extends GroupBase<OptionType>, Additional> = UseAsyncPaginateParams<OptionType, Group, Additional> & {
    inputValue: string;
    menuIsOpen: boolean;
};
type ComponentProps<OptionType, Group extends GroupBase<OptionType>, IsMulti extends boolean> = {
    selectRef?: Ref<SelectInstance<OptionType, IsMulti, Group>>;
    cacheUniqs?: ReadonlyArray<unknown>;
};
type AsyncPaginateProps<OptionType, Group extends GroupBase<OptionType>, Additional, IsMulti extends boolean> = Props<OptionType, IsMulti, Group> & UseAsyncPaginateParams<OptionType, Group, Additional> & ComponentProps<OptionType, Group, IsMulti>;
type WithAsyncPaginateType = <OptionType, Group extends GroupBase<OptionType>, Additional, IsMulti extends boolean = false>(props: AsyncPaginateProps<OptionType, Group, Additional, IsMulti>) => ReactElement;

type SelectComponentType = <Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>>(props: Props<Option, IsMulti, Group> & {
    ref?: Ref<SelectInstance<Option, IsMulti, Group>>;
}) => ReactElement;
declare function withAsyncPaginate(SelectComponent: SelectComponentType): WithAsyncPaginateType;

type MenuListType<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>> = ComponentType<MenuListProps<Option, IsMulti, Group>>;
declare function wrapMenuList<Option = unknown, IsMulti extends boolean = boolean, Group extends GroupBase<Option> = GroupBase<Option>>(MenuList: MenuListType<Option, IsMulti, Group>): (props: MenuListProps<Option, IsMulti, Group>) => ReactElement;

declare const reduceGroupedOptions: <OptionType, Group extends GroupBase<OptionType>>(prevOptions: OptionsOrGroups<OptionType, Group>, loadedOptions: OptionsOrGroups<OptionType, Group>) => OptionsOrGroups<OptionType, Group>;

declare const useComponents: <OptionType, Group extends GroupBase<OptionType>, IsMulti extends boolean>(components: SelectComponentsConfig<OptionType, IsMulti, Group>) => SelectComponentsConfig<OptionType, IsMulti, Group>;

declare const useAsyncPaginate: <OptionType, Group extends GroupBase<OptionType>, Additional>(params: UseAsyncPaginateParams<OptionType, Group, Additional>, deps?: ReadonlyArray<unknown>) => UseAsyncPaginateResult<OptionType, Group>;

declare const useAsyncPaginateBase: <OptionType, Group extends GroupBase<OptionType>, Additional>(params: UseAsyncPaginateBaseParams<OptionType, Group, Additional>, deps?: ReadonlyArray<unknown>) => UseAsyncPaginateBaseResult<OptionType, Group>;

declare const checkIsResponse: <OptionType, Group extends GroupBase<OptionType>, Additional>(response: unknown) => response is Response<OptionType, Group, Additional>;
declare const validateResponse: <OptionType, Group extends GroupBase<OptionType>, Additional>(response: unknown) => response is Response<OptionType, Group, Additional>;

declare const AsyncPaginate: WithAsyncPaginateType;

export { AsyncPaginate, type AsyncPaginateProps, type ComponentProps, type FilterOption, type LoadOptions, type OptionsCache, type OptionsCacheItem, type ReduceOptions, type RequestOptionsCallerType, type Response, type ShouldLoadMore, type UseAsyncPaginateBaseParams, type UseAsyncPaginateBaseResult, type UseAsyncPaginateParams, type UseAsyncPaginateResult, type WithAsyncPaginateType, checkIsResponse, reduceGroupedOptions, useAsyncPaginate, useAsyncPaginateBase, useComponents, validateResponse, withAsyncPaginate, wrapMenuList };