@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/esm/baseui/select/select.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import SelectComponent from './select-component';
+declare function Select(props: React.ComponentProps<typeof SelectComponent>): import("react/jsx-runtime").JSX.Element;
+export default Select;

package/esm/baseui/select/select.js

@@ -0,0 +1,9 @@
+import { __assign } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import SelectComponent from './select-component';
+import MultiValue from './multi-value';
+import SingleValue from './value';
+function Select(props) {
+    return _jsx(SelectComponent, __assign({}, props, { valueComponent: props.multi ? MultiValue : SingleValue }), void 0);
+}
+export default Select;

package/esm/baseui/select/single-select.d.ts

@@ -0,0 +1,3 @@
+import type { SelectProps } from './types';
+declare function SingleSelect(props: Partial<SelectProps>): import("react/jsx-runtime").JSX.Element;
+export default SingleSelect;

package/esm/baseui/select/single-select.js

@@ -0,0 +1,8 @@
+import { __assign } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import SelectComponent from './select-component';
+import Value from './value';
+function SingleSelect(props) {
+    return _jsx(SelectComponent, __assign({}, props, { multi: false, valueComponent: Value }), void 0);
+}
+export default SingleSelect;

package/esm/baseui/select/stateful-select-container.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import type { StatefulContainerProps, StateReducer, State, OnChangeParams } from './types';
+declare class StatefulSelectContainer extends React.Component<StatefulContainerProps, State> {
+    static defaultProps: {
+        initialState: {
+            value: never[];
+        };
+        onChange: () => void;
+        overrides: {};
+        stateReducer: StateReducer;
+    };
+    state: {
+        value: import("./types").Value;
+    };
+    onChange: (params: OnChangeParams) => void;
+    internalSetState: (params: OnChangeParams) => void;
+    render(): React.ReactNode;
+}
+export default StatefulSelectContainer;

package/esm/baseui/select/stateful-select-container.js

@@ -0,0 +1,46 @@
+import { __assign, __extends, __rest } from "tslib";
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+import * as React from 'react';
+var defaultStateReducer = function (type, nextState) { return nextState; };
+var StatefulSelectContainer = /** @class */ (function (_super) {
+    __extends(StatefulSelectContainer, _super);
+    function StatefulSelectContainer() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.state = __assign({}, _this.props.initialState);
+        _this.onChange = function (params) {
+            _this.internalSetState(params);
+            _this.props.onChange(params);
+        };
+        _this.internalSetState = function (params) {
+            var stateReducer = _this.props.stateReducer;
+            var nextState = { value: params.value };
+            _this.setState(stateReducer(params.type, nextState, _this.state));
+        };
+        return _this;
+    }
+    StatefulSelectContainer.prototype.render = function () {
+        var _a = this.props, children = _a.children, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        initialState = _a.initialState, // eslint-disable-line no-unused-vars
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        stateReducer = _a.stateReducer, // eslint-disable-line no-unused-vars
+        restProps = __rest(_a, ["children", "initialState", "stateReducer"]);
+        return children(__assign(__assign(__assign({}, restProps), this.state), { onChange: this.onChange }));
+    };
+    StatefulSelectContainer.defaultProps = {
+        initialState: {
+            // @ts-ignore
+            value: [],
+        },
+        onChange: function () { },
+        overrides: {},
+        stateReducer: defaultStateReducer,
+    };
+    return StatefulSelectContainer;
+}(React.Component));
+export default StatefulSelectContainer;

package/esm/baseui/select/stateful-select.d.ts

@@ -0,0 +1,76 @@
+import * as React from 'react';
+import type { StatefulSelectProps } from './types';
+declare function StatefulSelect(props: StatefulSelectProps): import("react/jsx-runtime").JSX.Element;
+declare namespace StatefulSelect {
+    var defaultProps: {
+        'aria-label': null;
+        'aria-describedby': null;
+        'aria-errormessage': null;
+        'aria-labelledby': null;
+        autoFocus: boolean;
+        backspaceRemoves: boolean;
+        clearable: boolean;
+        closeOnSelect: boolean;
+        creatable: boolean;
+        deleteRemoves: boolean;
+        disabled: boolean;
+        error: boolean;
+        positive: boolean;
+        escapeClearsValue: boolean;
+        filterOptions: (options: import("./types").Value, filterValue: string, excludeOptions?: import("./types").Value | null | undefined, newProps?: Partial<{
+            filterOption: ((option: Readonly<{
+                [x: string]: any;
+                id?: string | number | undefined;
+                label?: React.ReactNode;
+                disabled?: boolean | undefined;
+                clearableValue?: boolean | undefined;
+                isCreatable?: boolean | undefined;
+                __optgroup?: string | undefined;
+                searchTags?: string[] | undefined;
+            }>, filterValue: string) => boolean) | null | undefined;
+            ignoreCase: boolean;
+            labelKey: string;
+            matchPos: "start" | "any";
+            matchProp: "label" | "value" | "any";
+            trimFilter: boolean;
+            valueKey: string;
+        }> | null | undefined) => Readonly<{
+            [x: string]: any;
+            id?: string | number | undefined;
+            label?: React.ReactNode;
+            disabled?: boolean | undefined;
+            clearableValue?: boolean | undefined;
+            isCreatable?: boolean | undefined;
+            __optgroup?: string | undefined;
+            searchTags?: string[] | undefined;
+        }>[];
+        filterOutSelected: boolean;
+        getOptionLabel: null;
+        getValueLabel: null;
+        ignoreCase: boolean;
+        isLoading: boolean;
+        labelKey: string;
+        maxDropdownHeight: string;
+        multi: boolean;
+        onBlur: () => void;
+        onBlurResetsInput: boolean;
+        onChange: () => void;
+        onFocus: () => void;
+        onInputChange: () => void;
+        onCloseResetsInput: boolean;
+        onSelectResetsInput: boolean;
+        onOpen: null;
+        onClose: null;
+        openOnClick: boolean;
+        startOpen: boolean;
+        options: never[];
+        overrides: {};
+        required: boolean;
+        searchable: boolean;
+        size: "default";
+        type: "select";
+        value: never[];
+        valueKey: string;
+    };
+}
+export default StatefulSelect;

package/esm/baseui/select/stateful-select.js

@@ -0,0 +1,9 @@
+import { __assign } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import StatefulContainer from './stateful-select-container';
+import Select from './select';
+import defaultProps from './default-props';
+export default function StatefulSelect(props) {
+    return (_jsx(StatefulContainer, __assign({}, props, { children: function (childrenProps) { return _jsx(Select, __assign({}, childrenProps), void 0); } }), void 0));
+}
+StatefulSelect.defaultProps = defaultProps;

package/esm/baseui/select/styled-components.d.ts

@@ -0,0 +1,16 @@
+export declare const StyledDropdownContainer: import("../../style/styled").StyledComponent;
+export declare const StyledDropdown: () => null;
+export declare const StyledDropdownListItem: () => null;
+export declare const StyledOptionContent: import("../../style/styled").StyledComponent;
+export declare const StyledRoot: import("../../style/styled").StyledComponent;
+export declare const StyledControlContainer: import("../../style/styled").StyledComponent;
+export declare const StyledValueContainer: import("../../style/styled").StyledComponent;
+export declare const StyledPlaceholder: import("../../style/styled").StyledComponent;
+export declare const StyledSingleValue: import("../../style/styled").StyledComponent;
+export declare const StyledInputContainer: import("../../style/styled").StyledComponent;
+export declare const StyledInput: import("../../style/styled").StyledComponent;
+export declare const StyledInputSizer: import("../../style/styled").StyledComponent;
+export declare const StyledIconsContainer: import("../../style/styled").StyledComponent;
+export declare const StyledSelectArrow: import("../../style/styled").StyledComponent;
+export declare const StyledClearIcon: import("../../style/styled").StyledComponent;
+export declare const StyledSearchIconContainer: import("../../style/styled").StyledComponent;

package/esm/baseui/select/styled-components.js

@@ -0,0 +1,93 @@
+import { __assign } from "tslib";
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+import { styled } from '../../style';
+import { TYPE } from './constants';
+export var StyledDropdownContainer = styled('div', function (utils, props) {
+    return {
+        width: "".concat(String(props.$width), "px"),
+    };
+});
+StyledDropdownContainer.displayName = 'StyledDropdownContainer';
+export var StyledDropdown = function () { return null; };
+export var StyledDropdownListItem = function () { return null; };
+export var StyledOptionContent = styled('div', function (utils, props) {
+    var $selected = props.$selected, $disabled = props.$disabled;
+    return {
+        cursor: $disabled ? 'not-allowed' : 'pointer',
+        fontWeight: $selected ? 'bold' : 'normal',
+    };
+});
+StyledOptionContent.displayName = 'StyledOptionContent';
+export var StyledRoot = styled('div', 'box-border relative w-full');
+StyledRoot.displayName = 'StyledRoot';
+export var StyledControlContainer = styled('div', 'box-border overflow-hidden w-full flex justify-between', function (utils, props) {
+    var theme = utils.theme;
+    var $disabled = props.$disabled, $type = props.$type, $searchable = props.$searchable;
+    return {
+        borderStyle: 'solid',
+        cursor: $disabled ? 'not-allowed' : $searchable || $type === TYPE.search ? 'text' : 'pointer',
+        // TODO confirm the background color
+        backgroundColor: $disabled ? theme.spr.interactiveDisable : theme.spr.ui01,
+        transitionProperty: 'border, box-shadow, background-color',
+    };
+});
+StyledControlContainer.displayName = 'StyledControlContainer';
+export var StyledValueContainer = styled('div', 'box-border relative flex-1 flex items-center overflow-hidden', function (utils, props) {
+    return {
+        flexWrap: props.$multi ? 'wrap' : 'nowrap',
+    };
+});
+StyledValueContainer.displayName = 'StyledValueContainer';
+export var StyledPlaceholder = styled('div', 'max-w-full truncate');
+StyledPlaceholder.displayName = 'StyledPlaceholder';
+export var StyledSingleValue = styled('div', 'box-border h-full max-w-full truncate ml-0.5', {
+    wordWrap: 'normal',
+});
+StyledSingleValue.displayName = 'StyledSingleValue';
+export var StyledInputContainer = styled('div', 'relative inline-block max-w-full bg-transparent border-none box-border outline-none', {
+    boxShadow: 'none',
+    marginTop: 0,
+    marginBottom: 0,
+    marginRight: 0,
+    paddingTop: 0,
+    paddingBottom: 0,
+    paddingLeft: 0,
+    paddingRight: 0,
+});
+StyledInputContainer.displayName = 'StyledInputContainer';
+export var StyledInput = styled('input', 'box-content inline-block max-w-full bg-transparent', function (utils, props) {
+    var $searchable = props.$searchable, $width = props.$width;
+    return {
+        width: !$searchable ? '1px' : $width || '100%',
+        outline: 'none',
+    };
+});
+StyledInput.displayName = 'StyledInput';
+export var StyledInputSizer = styled('div', 'absolute top-0 invisible h-0 overflow-scroll whitespace-pre');
+StyledInputSizer.displayName = 'StyledInputSizer';
+export var StyledIconsContainer = styled('div', 'box-border relative flex flex-shrink-0 items-center self-stretch');
+StyledIconsContainer.displayName = 'StyledIconsContainer';
+// @ts-ignore
+function getSvgStyles() {
+    return {
+        display: 'inline-block',
+        fill: 'currentColor',
+        color: 'currentColor',
+    };
+}
+export var StyledSelectArrow = styled('svg', 'h-4 w-4', function (utils, props) {
+    var $disabled = props.$disabled;
+    return __assign(__assign({}, getSvgStyles()), { cursor: $disabled ? 'not-allowed' : 'pointer' });
+});
+StyledSelectArrow.displayName = 'StyledSelectArrow';
+export var StyledClearIcon = styled('svg', 'h-4 w-4 cursor-pointer', __assign({}, getSvgStyles()));
+export var StyledSearchIconContainer = styled('div', 'h-4 w-4 absolute top-0 flex h-full items-center', function (utils, props) {
+    var $disabled = props.$disabled;
+    return __assign(__assign({}, getSvgStyles()), { cursor: $disabled ? 'not-allowed' : 'pointer' });
+});
+StyledSearchIconContainer.displayName = 'StyledSearchIconContainer';

package/esm/baseui/select/types.d.ts

@@ -0,0 +1,290 @@
+import type * as React from 'react';
+import type { Override } from '../helpers/overrides';
+import type { STATE_CHANGE_TYPE, SIZE, TYPE } from './constants';
+import type { OnItemSelectFn } from '../menu';
+export declare type ChangeAction = keyof typeof STATE_CHANGE_TYPE;
+export declare type Size = keyof typeof SIZE;
+export declare type Type = keyof typeof TYPE;
+export declare type Option = Readonly<{
+    id?: string | number;
+    label?: React.ReactNode;
+    disabled?: boolean;
+    clearableValue?: boolean;
+    isCreatable?: boolean;
+    __optgroup?: string;
+    searchTags?: Array<string>;
+    [x: string]: any;
+}>;
+export declare type Value = ReadonlyArray<Option>;
+export declare type Optgroups = {
+    __ungrouped?: Value;
+    [x: string]: Value;
+};
+export declare type Options = Value | undefined | null | Optgroups;
+export declare type OnChangeParams = {
+    value: Value;
+    option: Option | undefined | null;
+    type: ChangeAction;
+};
+export declare type SelectOverrides = {
+    Root?: Override;
+    ControlContainer?: Override;
+    Placeholder?: Override;
+    ValueContainer?: Override;
+    SingleValue?: Override;
+    MultiValue?: Override;
+    Tag?: Override;
+    InputContainer?: Override;
+    Input?: Override;
+    IconsContainer?: Override;
+    SelectArrow?: Override;
+    ClearIcon?: Override;
+    LoadingIndicator?: Override;
+    SearchIconContainer?: Override;
+    SearchIcon?: Override;
+    Popover?: Override;
+    DropdownContainer?: Override;
+    Dropdown?: Override;
+    DropdownOption?: Override;
+    DropdownListItem?: Override;
+    OptionContent?: Override;
+    StatefulMenu?: Override;
+    StyledClearIcon?: Override;
+};
+export declare type OverridesDropdown = {
+    DropdownContainer?: Override;
+    Dropdown?: Override;
+    DropdownOption?: Override;
+    DropdownListItem?: Override;
+    OptionContent?: Override;
+    StatefulMenu?: Override;
+};
+export declare type ImperativeMethods = {
+    setDropdownOpen: (a: boolean) => unknown;
+    setInputValue: (a: string) => void;
+    setInputFocus: () => void;
+    setInputBlur: () => void;
+    focus: () => void;
+    blur: () => void;
+};
+export declare type ControlRef = {
+    current: ImperativeMethods | null;
+};
+export declare type SelectProps = {
+    /**
+     * This is an internal prop being used in Overlay Select. Not meant for consumer.
+     * If set, filterOptions will use it as inputValue
+     */
+    __inputValue?: string;
+    /**
+     * This is an internal prop being used in AsyncSelect. Not meant for consumer.
+     * If true, selectAll event won't return all options in values.
+     */
+    __selectAllShouldReturnAllOptions?: boolean;
+    /**
+     * This is an internal prop being used in AsyncSelect.
+     * Selected state of SelectAll option will be decided based on this prop if __selectAllShouldReturnAllOptions is true.
+     */
+    __selectAllSelected?: boolean;
+    hideSelectAll?: boolean;
+    'aria-label'?: string | null;
+    'aria-describedby'?: string | null;
+    'aria-errormessage'?: string | null;
+    'aria-labelledby'?: string | null;
+    /** Defines if select element is focused on the first mount. */
+    autoFocus?: boolean;
+    /** Defines if options can be removed by pressing backspace. If you have customized labels, it will remove the option entirely, otherwise, it starts removing characters from the end of the string. */
+    backspaceRemoves?: boolean;
+    /** By default, backspace will only remove the last character of the input value. If true, the input value will be cleared. */
+    backspaceClearsInputValue?: boolean;
+    /** Defines if the select value can be cleared. If true a clear icon is rendered when a value is set. */
+    clearable?: boolean;
+    /** Defines if the menu closes after a selection if made. */
+    closeOnSelect?: boolean;
+    /** Defines if new options can be created along with choosing existing options. */
+    creatable?: boolean;
+    /** Defines if options can be removed by pressing backspace. */
+    deleteRemoves?: boolean;
+    /** Defines if the control is disabled. */
+    disabled?: boolean;
+    /** Defines if the control is in error state. */
+    error?: boolean;
+    /** Defines if the control is in positive state. */
+    positive?: boolean;
+    /** Defines if the value is cleared when escape is pressed and the dropdown is closed. */
+    escapeClearsValue?: boolean;
+    /** Defaults to filterOptions that excludes selected options for
+     * multi select. A custom method to filter options to be displayed in the dropdown. */
+    filterOptions?: ((options: Value, filterValue: string, excludeOptions: Value | undefined | null, a: {
+        valueKey: string;
+        labelKey: string;
+    }) => Value) | null;
+    /** Defines if currently selected options are filtered out in the dropdown options. */
+    filterOutSelected?: boolean;
+    /** A custom method to get a display value for a dropdown option. */
+    getOptionLabel?: ((a: {
+        option: Option;
+        optionState: {
+            $selected: boolean;
+            $disabled: boolean;
+            $isHighlighted: boolean;
+        };
+    }) => React.ReactNode) | null;
+    /** A custom method to get a display value for a selected option. */
+    getValueLabel?: ((a: {
+        option: Option;
+        index?: number;
+    }) => React.ReactNode) | null;
+    /** Sets the id attribute of the internal input element. Allows for usage with labels. */
+    id?: string;
+    /** Defines if the comparison for a new creatable value should be case-insensitive. */
+    ignoreCase?: boolean;
+    inputRef?: React.Ref<HTMLInputElement>;
+    /** An imperative handle exposing internal methods. */
+    controlRef?: ControlRef;
+    /** Defines if the select is in a loading (async) state. */
+    isLoading?: boolean;
+    /** Defines an option key for a default label value. */
+    labelKey?: string;
+    /** Sets max height of the dropdown list. */
+    maxDropdownHeight?: string;
+    /** Defines if multiple options can be selected. */
+    multi?: boolean;
+    /** Message to be displayed if no options is found for a search query. */
+    noResultsMsg?: React.ReactNode;
+    onBlur?: (e: React.FocusEvent | MouseEvent) => unknown;
+    /** Defines if the input value is reset to an empty string when a blur event happens on the select. */
+    onBlurResetsInput?: boolean;
+    /** change handler of the select to be called when a value is changed. */
+    onChange?: (params: OnChangeParams) => unknown;
+    onFocus?: (e: React.SyntheticEvent<HTMLElement>) => unknown;
+    onInputChange?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Defines if the input value is reset to an empty string when dropdown is closed. */
+    onCloseResetsInput?: boolean;
+    /** Defines if the input value is reset to an empty string when a selection is made. */
+    onSelectResetsInput?: boolean;
+    /** A function that is called when the dropdown opens. */
+    onOpen?: (() => unknown) | null;
+    /** A function that is called when the dropdown closes. */
+    onClose?: (() => unknown) | undefined | null;
+    /** Defines if the dropdown opens on a click event on the select. */
+    openOnClick?: boolean;
+    /** If true, opens the dropdown when the select mounts. */
+    startOpen?: boolean;
+    /** Options to be displayed in the dropdown. If an option has a
+     * disabled prop value set to true it will be rendered as a disabled option in the dropdown. */
+    options?: Options;
+    overrides?: SelectOverrides;
+    /** Sets the placeholder. */
+    placeholder?: React.ReactNode;
+    /** Defines if the select field is required to have a selection. */
+    required?: boolean;
+    /** Defines if the search functionality is enabled. */
+    searchable?: boolean;
+    /** Defines the size (scale) of dropdown menu items. See the Menu component API. */
+    size?: Size;
+    /** Defines type of the component to be in select or search mode.
+     * When set to TYPE.search the search icon is rendered on the
+     * left and the select arrow icon is not rendered. */
+    type?: Type;
+    /** A current selected value(s). If a selected value has a clearableValue
+     * prop set to true it will be rendered as a disabled selected option that can't be cleared. */
+    value?: Value;
+    valueComponent?: React.ComponentType<any>;
+    /** Defines a key name for an option's unique identifier value.
+     * The value of the `valueKey` prop is used to identify what options are selected
+     * or removed from the selection, it also used for default filtering out the
+     * selected options from the dropdown list. */
+    valueKey?: string;
+    /** Where to mount the popover */
+    mountNode?: HTMLElement;
+};
+export declare type SelectState = {
+    activeDescendant: string | undefined | null;
+    inputValue: string;
+    isFocused: boolean;
+    isOpen: boolean;
+    isPseudoFocused: boolean;
+};
+export declare type State = {
+    value: Value;
+};
+export declare type StateReducer = (stateType: string, nextState: State, currentState: State) => State;
+export declare type StatefulContainerProps = {
+    overrides: SelectOverrides;
+    children: (a: SelectProps) => React.ReactNode;
+    initialState: State;
+    stateReducer: StateReducer;
+    onChange: (params: OnChangeParams) => unknown;
+};
+export declare type StatefulSelectProps = Omit<SelectProps, 'onChange' | 'overrides' | 'initialState' | 'stateReducer'> & {
+    overrides?: SelectOverrides;
+    initialState?: State;
+    stateReducer?: StateReducer;
+    onChange?: (params: OnChangeParams) => unknown;
+};
+export declare type DropdownProps = {
+    selectAllChecked?: boolean;
+    error: boolean;
+    getOptionLabel: (a: {
+        option: Option;
+        optionState: {
+            $selected: boolean;
+            $disabled: boolean;
+            $isHighlighted: boolean;
+        };
+    }) => React.ReactNode;
+    id?: string;
+    innerRef: React.Ref<HTMLElement>;
+    isLoading: boolean;
+    labelKey: string;
+    maxDropdownHeight: string;
+    multi: boolean;
+    noResultsMsg?: React.ReactNode;
+    onActiveDescendantChange?: (id?: string) => unknown;
+    onItemSelect: OnItemSelectFn;
+    options: Value;
+    overrides?: OverridesDropdown;
+    required: boolean;
+    searchable: boolean;
+    size: Size;
+    type: Type;
+    value: Value;
+    valueKey: string;
+    width: number | undefined | null;
+    keyboardControlNode?: React.Ref<HTMLElement>;
+};
+export declare type AutosizeInputOverrides = {
+    Input?: Override;
+};
+export declare type AutosizeInputProps = {
+    value: string;
+    defaultValue?: string;
+    inputRef?: (ref: any) => any;
+    overrides?: AutosizeInputOverrides;
+    $size?: Size;
+};
+export declare type AutosizeInputState = {
+    inputWidth: number;
+};
+export declare type SharedStylePropsArg = {
+    $clearable?: boolean;
+    $creatable?: boolean;
+    $disabled?: boolean;
+    $error?: boolean;
+    $positive?: boolean;
+    $isFocused?: boolean;
+    $isLoading?: boolean;
+    $isOpen?: boolean;
+    $isPseudoFocused?: boolean;
+    $multi?: boolean;
+    $required?: boolean;
+    $searchable?: boolean;
+    $size?: Size;
+    $type?: Type;
+    $width?: string;
+    $maxHeight?: string;
+    $isHighlighted?: boolean;
+    $selected?: boolean;
+    $isEmpty?: boolean;
+};

package/esm/baseui/select/types.js

@@ -0,0 +1 @@
+export {};

package/esm/baseui/select/utils/default-filter-options.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import type { Option, Value } from '../types';
+declare type defaultProps = {
+    filterOption: ((option: Option, filterValue: string) => boolean) | undefined | null;
+    ignoreCase: boolean;
+    labelKey: string;
+    matchPos: 'any' | 'start';
+    matchProp: 'any' | 'label' | 'value';
+    trimFilter: boolean;
+    valueKey: string;
+};
+declare const defaultProps: defaultProps;
+declare const filterOptions: (options: Value, filterValue: string, excludeOptions?: Value | null | undefined, newProps?: Partial<defaultProps> | null | undefined) => Readonly<{
+    [x: string]: any;
+    id?: string | number | undefined;
+    label?: import("react").ReactNode;
+    disabled?: boolean | undefined;
+    clearableValue?: boolean | undefined;
+    isCreatable?: boolean | undefined;
+    __optgroup?: string | undefined;
+    searchTags?: string[] | undefined;
+}>[];
+export default filterOptions;

package/esm/baseui/select/utils/default-filter-options.js

@@ -0,0 +1,52 @@
+import { __assign } from "tslib";
+// @ts-ignore
+var escapeRegExp = function (str) { return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); };
+// @ts-ignore
+var isValid = function (value) { return typeof value !== 'undefined' && value !== null && value !== ''; };
+var defaultProps = {
+    filterOption: null,
+    ignoreCase: true,
+    labelKey: 'label',
+    matchPos: 'any',
+    matchProp: 'any',
+    trimFilter: true,
+    valueKey: 'value',
+};
+var filterOptions = function (options, filterValue, excludeOptions, newProps) {
+    var props = __assign(__assign({}, defaultProps), newProps);
+    if (props.ignoreCase) {
+        filterValue = filterValue.toLowerCase();
+    }
+    if (props.trimFilter) {
+        filterValue = filterValue.trim();
+    }
+    var excludeValues = (excludeOptions || []).reduce(function (acc, option) {
+        acc.add(option[props.valueKey]);
+        return acc;
+    }, new Set());
+    var re = new RegExp("".concat(props.matchPos === 'start' ? '^' : '').concat(escapeRegExp(filterValue)), props.ignoreCase ? 'i' : '');
+    return options.filter(function (option) {
+        if (excludeValues.has(option[props.valueKey]))
+            return false;
+        if (props.filterOption)
+            return props.filterOption.call(undefined, option, filterValue);
+        if (!filterValue)
+            return true;
+        var value = option[props.valueKey];
+        var label = option[props.labelKey];
+        var searchTags = option.searchTags;
+        var hasValue = isValid(value);
+        var hasLabel = isValid(label);
+        if (!hasValue && !hasLabel) {
+            return false;
+        }
+        var valueTest = hasValue ? String(value) : null;
+        var labelTest = hasLabel ? String(label) : null;
+        return ((valueTest && props.matchProp !== 'label' && re.test(valueTest)) ||
+            (labelTest && props.matchProp !== 'value' && re.test(labelTest)) ||
+            (Array.isArray(searchTags) &&
+                props.matchProp !== 'value' &&
+                searchTags.some(function (searchTag) { return isValid(searchTag) && re.test(String(searchTag)); })));
+    });
+};
+export default filterOptions;

package/esm/baseui/select/utils/index.d.ts

@@ -0,0 +1,3 @@
+import type { SelectProps, Option, Options, Value } from '../types';
+export declare function normalizeOptions(options: Options): Value;
+export declare const expandValue: (value: Option, props: Partial<SelectProps>) => Option;