@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/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/baseui/select/select.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+var select_component_1 = (0, tslib_1.__importDefault)(require("./select-component"));
+var multi_value_1 = (0, tslib_1.__importDefault)(require("./multi-value"));
+var value_1 = (0, tslib_1.__importDefault)(require("./value"));
+function Select(props) {
+    return (0, jsx_runtime_1.jsx)(select_component_1.default, (0, tslib_1.__assign)({}, props, { valueComponent: props.multi ? multi_value_1.default : value_1.default }), void 0);
+}
+exports.default = Select;

package/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/baseui/select/single-select.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+var select_component_1 = (0, tslib_1.__importDefault)(require("./select-component"));
+var value_1 = (0, tslib_1.__importDefault)(require("./value"));
+function SingleSelect(props) {
+    return (0, jsx_runtime_1.jsx)(select_component_1.default, (0, tslib_1.__assign)({}, props, { multi: false, valueComponent: value_1.default }), void 0);
+}
+exports.default = SingleSelect;

package/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/baseui/select/stateful-select-container.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("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.
+*/
+var React = (0, tslib_1.__importStar)(require("react"));
+var defaultStateReducer = function (type, nextState) { return nextState; };
+var StatefulSelectContainer = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(StatefulSelectContainer, _super);
+    function StatefulSelectContainer() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.state = (0, tslib_1.__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 = (0, tslib_1.__rest)(_a, ["children", "initialState", "stateReducer"]);
+        return children((0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, restProps), this.state), { onChange: this.onChange }));
+    };
+    StatefulSelectContainer.defaultProps = {
+        initialState: {
+            // @ts-ignore
+            value: [],
+        },
+        onChange: function () { },
+        overrides: {},
+        stateReducer: defaultStateReducer,
+    };
+    return StatefulSelectContainer;
+}(React.Component));
+exports.default = StatefulSelectContainer;

package/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/baseui/select/stateful-select.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+var stateful_select_container_1 = (0, tslib_1.__importDefault)(require("./stateful-select-container"));
+var select_1 = (0, tslib_1.__importDefault)(require("./select"));
+var default_props_1 = (0, tslib_1.__importDefault)(require("./default-props"));
+function StatefulSelect(props) {
+    return ((0, jsx_runtime_1.jsx)(stateful_select_container_1.default, (0, tslib_1.__assign)({}, props, { children: function (childrenProps) { return (0, jsx_runtime_1.jsx)(select_1.default, (0, tslib_1.__assign)({}, childrenProps), void 0); } }), void 0));
+}
+exports.default = StatefulSelect;
+StatefulSelect.defaultProps = default_props_1.default;

package/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/baseui/select/styled-components.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyledSearchIconContainer = exports.StyledClearIcon = exports.StyledSelectArrow = exports.StyledIconsContainer = exports.StyledInputSizer = exports.StyledInput = exports.StyledInputContainer = exports.StyledSingleValue = exports.StyledPlaceholder = exports.StyledValueContainer = exports.StyledControlContainer = exports.StyledRoot = exports.StyledOptionContent = exports.StyledDropdownListItem = exports.StyledDropdown = exports.StyledDropdownContainer = void 0;
+var tslib_1 = require("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.
+*/
+var style_1 = require("../../style");
+var constants_1 = require("./constants");
+exports.StyledDropdownContainer = (0, style_1.styled)('div', function (utils, props) {
+    return {
+        width: "".concat(String(props.$width), "px"),
+    };
+});
+exports.StyledDropdownContainer.displayName = 'StyledDropdownContainer';
+var StyledDropdown = function () { return null; };
+exports.StyledDropdown = StyledDropdown;
+var StyledDropdownListItem = function () { return null; };
+exports.StyledDropdownListItem = StyledDropdownListItem;
+exports.StyledOptionContent = (0, style_1.styled)('div', function (utils, props) {
+    var $selected = props.$selected, $disabled = props.$disabled;
+    return {
+        cursor: $disabled ? 'not-allowed' : 'pointer',
+        fontWeight: $selected ? 'bold' : 'normal',
+    };
+});
+exports.StyledOptionContent.displayName = 'StyledOptionContent';
+exports.StyledRoot = (0, style_1.styled)('div', 'box-border relative w-full');
+exports.StyledRoot.displayName = 'StyledRoot';
+exports.StyledControlContainer = (0, style_1.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 === constants_1.TYPE.search ? 'text' : 'pointer',
+        // TODO confirm the background color
+        backgroundColor: $disabled ? theme.spr.interactiveDisable : theme.spr.ui01,
+        transitionProperty: 'border, box-shadow, background-color',
+    };
+});
+exports.StyledControlContainer.displayName = 'StyledControlContainer';
+exports.StyledValueContainer = (0, style_1.styled)('div', 'box-border relative flex-1 flex items-center overflow-hidden', function (utils, props) {
+    return {
+        flexWrap: props.$multi ? 'wrap' : 'nowrap',
+    };
+});
+exports.StyledValueContainer.displayName = 'StyledValueContainer';
+exports.StyledPlaceholder = (0, style_1.styled)('div', 'max-w-full truncate');
+exports.StyledPlaceholder.displayName = 'StyledPlaceholder';
+exports.StyledSingleValue = (0, style_1.styled)('div', 'box-border h-full max-w-full truncate ml-0.5', {
+    wordWrap: 'normal',
+});
+exports.StyledSingleValue.displayName = 'StyledSingleValue';
+exports.StyledInputContainer = (0, style_1.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,
+});
+exports.StyledInputContainer.displayName = 'StyledInputContainer';
+exports.StyledInput = (0, style_1.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',
+    };
+});
+exports.StyledInput.displayName = 'StyledInput';
+exports.StyledInputSizer = (0, style_1.styled)('div', 'absolute top-0 invisible h-0 overflow-scroll whitespace-pre');
+exports.StyledInputSizer.displayName = 'StyledInputSizer';
+exports.StyledIconsContainer = (0, style_1.styled)('div', 'box-border relative flex flex-shrink-0 items-center self-stretch');
+exports.StyledIconsContainer.displayName = 'StyledIconsContainer';
+// @ts-ignore
+function getSvgStyles() {
+    return {
+        display: 'inline-block',
+        fill: 'currentColor',
+        color: 'currentColor',
+    };
+}
+exports.StyledSelectArrow = (0, style_1.styled)('svg', 'h-4 w-4', function (utils, props) {
+    var $disabled = props.$disabled;
+    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, getSvgStyles()), { cursor: $disabled ? 'not-allowed' : 'pointer' });
+});
+exports.StyledSelectArrow.displayName = 'StyledSelectArrow';
+exports.StyledClearIcon = (0, style_1.styled)('svg', 'h-4 w-4 cursor-pointer', (0, tslib_1.__assign)({}, getSvgStyles()));
+exports.StyledSearchIconContainer = (0, style_1.styled)('div', 'h-4 w-4 absolute top-0 flex h-full items-center', function (utils, props) {
+    var $disabled = props.$disabled;
+    return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, getSvgStyles()), { cursor: $disabled ? 'not-allowed' : 'pointer' });
+});
+exports.StyledSearchIconContainer.displayName = 'StyledSearchIconContainer';

package/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/baseui/select/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/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;