@sprinklrjs/spaceweb 10.1.0

package/esm/select/overrides.js

@@ -0,0 +1,125 @@
+import { __assign, __rest } from "tslib";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { chevronStyles, transparentScrollbarStyles } from '../helpers/commonStyles';
+import { getComponentSizeTheme } from '../helpers/themeHelpers';
+import ChevronDown from '../icon/components/chevron-down';
+import { borderColor, borderWidth } from '../helpers/longHandHelpers';
+import { getInputStyles } from '../input/styled-components';
+var selectBorderColor = function (_a, _b) {
+    var theme = _a.theme;
+    var _c = _b.$intent, $intent = _c === void 0 ? 'default' : _c, $isPseudoFocused = _b.$isPseudoFocused, $isFocused = _b.$isFocused, $disabled = _b.$disabled;
+    switch ($intent) {
+        case 'default':
+        default: {
+            if ($isPseudoFocused || $isFocused)
+                return borderColor(theme.spr.interactive01);
+            if ($disabled)
+                return borderColor(theme.input.disabledBorderColor);
+            return __assign(__assign({}, borderColor(theme.spr.field)), { ':hover': __assign({}, borderColor(theme.spr.border06)) });
+        }
+        case 'success':
+            return borderColor(theme.spr.supportSuccess);
+        case 'warning':
+            return borderColor(theme.spr.supportWarning);
+        case 'error':
+            return borderColor(theme.spr.supportError);
+    }
+};
+// Removing 'overrides' injected by baseweb
+export var SelectArrow = function (_a) {
+    var $isOpen = _a.$isOpen, title = _a.title, overrides = _a.overrides, restProps = __rest(_a, ["$isOpen", "title", "overrides"]);
+    return (_jsx(ChevronDown, __assign({ title: title, "$isOpen": $isOpen }, restProps, { className: [chevronStyles, 'ml-1 cursor-pointer', restProps === null || restProps === void 0 ? void 0 : restProps.className] }), void 0));
+};
+export var getSearchIconContainerStyles = ['flex relative items-center top-0 left-0 h-auto mr-2'];
+export var getSearchIconStyles = function (_a, _b) {
+    var theme = _a.theme;
+    var $isOpen = _b.$isOpen;
+    return ({
+        color: $isOpen ? theme.spr.interactive01 : 'currentColor',
+    });
+};
+export var getControlContainerStyles = [
+    getInputStyles,
+    // Applying paddingX only. paddingY will be applied on ValueContainer.
+    'py-0 px-3 transition-none overflow-auto',
+    selectBorderColor,
+    transparentScrollbarStyles,
+    function (utils, props) {
+        var $multi = props.$multi, $isEmpty = props.$isEmpty, $type = props.$type;
+        // Override paddingLeft for multiSelect when values are selected
+        var shouldOverridePaddingLeft = $multi && !$isEmpty && $type !== 'search';
+        return __assign(__assign(__assign({}, borderWidth(utils.theme.borderWidth.default)), (shouldOverridePaddingLeft && { paddingLeft: utils.px2rem(2) })), { maxHeight: '120px' });
+    },
+];
+export var getValueContainerStyles = [
+    // For single Select read theme values from theme.input, form multiSelect read theme values from theme.multiSelect
+    getInputStyles,
+    // Applying paddingY only. paddingX will be applied on ControlContainer.
+    'px-0 self-start',
+    function (_a, _b) {
+        var theme = _a.theme;
+        var $multi = _b.$multi, $isEmpty = _b.$isEmpty, $size = _b.$size;
+        var multiSelectTheme = getComponentSizeTheme(theme, 'multiSelect', $size, 'lg');
+        return $multi && !$isEmpty
+            ? {
+                paddingTop: multiSelectTheme.paddingY,
+                paddingBottom: multiSelectTheme.paddingY,
+            }
+            : {};
+    },
+];
+export var getValueTypography = function (_a, _b) {
+    var theme = _a.theme;
+    var $selectSize = _b.$selectSize;
+    var _c = getComponentSizeTheme(theme, 'input', $selectSize, 'lg'), fontSize = _c.fontSize, lineHeight = _c.lineHeight;
+    return { fontSize: fontSize, lineHeight: lineHeight, height: lineHeight };
+};
+export var getSelectInputStyles = function () { return ({
+    color: 'inherit',
+    lineHeight: 'inherit',
+    fontSize: 'inherit',
+    fontWeight: 'inherit',
+    letterSpacing: 'normal',
+}); };
+// BaseSelect wil render this Popover component with DropdownContainer as content and ControlContainer as children/target
+export var OverlaySelectPopoverOverride = function (_a) {
+    var content = _a.content, inputContainer = _a.children, setStickySentinelRef = _a.setStickySentinelRef;
+    return (_jsxs(_Fragment, { children: [_jsx("div", { ref: setStickySentinelRef }, void 0), inputContainer, typeof content === 'function' ? content() : content] }, void 0));
+};
+export var selectMenuOverrides = {
+    Menu: {
+        props: {
+            overrides: {
+                List: {
+                    props: {
+                        overrides: {
+                            Root: {
+                                style: function (_, _a) {
+                                    var $maxHeight = _a.$maxHeight;
+                                    return ({ maxHeight: $maxHeight, overflow: 'auto' });
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    MenuItem: {
+        props: {
+            overrides: {
+                ListItem: {
+                    props: {
+                        overrides: {
+                            Root: {
+                                style: {
+                                    wordBreak: 'break-word',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};

package/esm/select/select-variants.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { SelectProps } from './types';
+export declare function MultiSelect(props: SelectProps): React.ReactElement;
+export declare function SingleSelect(props: SelectProps): React.ReactElement;

package/esm/select/select-variants.js

@@ -0,0 +1,9 @@
+import { __assign } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import Select from './select';
+export function MultiSelect(props) {
+    return _jsx(Select, __assign({}, props, { multi: true }), void 0);
+}
+export function SingleSelect(props) {
+    return _jsx(Select, __assign({}, props, { multi: false }), void 0);
+}

package/esm/select/select.d.ts

@@ -0,0 +1,42 @@
+import { SelectProps } from './types';
+import defaultProps from './default-props';
+declare const Select: {
+    (props: SelectProps & typeof defaultProps): React.ReactElement;
+    defaultProps: {
+        autoFocus: boolean;
+        backspaceRemoves: boolean;
+        clearable: boolean;
+        closeOnSelect: boolean;
+        creatable: boolean;
+        deleteRemoves: boolean;
+        disabled: boolean;
+        error: boolean;
+        positive: boolean;
+        escapeClearsValue: boolean;
+        filterOptions: any;
+        filterOutSelected: boolean;
+        isLoading: boolean;
+        labelKey: string;
+        maxDropdownHeight: string;
+        multi: boolean;
+        onBlur: (...args: any[]) => void;
+        onBlurResetsInput: boolean;
+        onChange: (...args: any[]) => void;
+        onFocus: (...args: any[]) => void;
+        onInputChange: (...args: any[]) => void;
+        onCloseResetsInput: boolean;
+        onSelectResetsInput: boolean;
+        openOnClick: boolean;
+        startOpen: boolean;
+        options: import("baseui/select").OptionsT;
+        overrides: {};
+        required: boolean;
+        searchable: boolean;
+        size: import("./types").Size;
+        type: "overlay" | import("./types").Type | "mobile";
+        value: import("baseui/select").Value;
+        valueKey: string;
+        placement: "auto" | "bottom" | "left" | "right" | "top" | "topLeft" | "topRight" | "rightTop" | "rightBottom" | "bottomLeft" | "bottomRight" | "leftTop" | "leftBottom" | undefined;
+    };
+};
+export default Select;

package/esm/select/select.js

@@ -0,0 +1,20 @@
+import { __assign } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import BaseSelect from './base-select';
+import OverlaySelect from './overlaySelect';
+import MobileSelect from './mobileSelect';
+import defaultProps from './default-props';
+import { useContextualFormProps } from '../form-control/context';
+var Select = function (props) {
+    var adaptedProps = useContextualFormProps(props);
+    switch (adaptedProps.type) {
+        case 'overlay':
+            return _jsx(OverlaySelect, __assign({}, adaptedProps), void 0);
+        case 'mobile':
+            return _jsx(MobileSelect, __assign({}, adaptedProps), void 0);
+        default:
+            return _jsx(BaseSelect, __assign({}, adaptedProps), void 0);
+    }
+};
+Select.defaultProps = defaultProps;
+export default Select;

package/esm/select/selectMenuAdapter/SelectMenuAdapter.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { StatefulMenuProps as BaseStatefulMenuProps } from 'baseui/menu';
+import { MenuItemProps, MenuProps } from '../../menu';
+import { Override } from '../../overrides';
+import { SelectProps } from '../types';
+declare type PropsAddedByOverride = {
+    id?: string;
+    value: SelectProps['value'];
+    overrides?: {
+        Menu?: Override<MenuProps>;
+        MenuItem?: Override<MenuItemProps & {
+            $multi: boolean;
+            $item: unknown;
+            $labelKey: string;
+        }>;
+        NoResults?: Override<{}>;
+        Divider?: Override<{
+            title: string;
+        }>;
+        ListItemText?: Override<{
+            $multi: boolean;
+            $item: unknown;
+            $labelKey: string;
+        }>;
+    };
+    valueKey: string;
+    labelKey: string;
+    multi: SelectProps['multi'];
+    selectAllSelected: boolean;
+    noResultsMsg?: string;
+    captureScroll?: boolean;
+};
+declare const SelectMenuAdapter: (props: BaseStatefulMenuProps & PropsAddedByOverride) => React.ReactElement;
+export default SelectMenuAdapter;

package/esm/select/selectMenuAdapter/SelectMenuAdapter.js

@@ -0,0 +1,72 @@
+import { __assign, __read } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import _flatten from 'lodash/flatten';
+import _isEmpty from 'lodash/isEmpty';
+import _map from 'lodash/map';
+import _noop from 'lodash/noop';
+import _omit from 'lodash/omit';
+import { Divider } from '../../list';
+import { Menu } from '../../menu';
+import { mergeOverrides, useOverrides } from '../../overrides';
+import { Typography } from '../../typography';
+import { UNGROUPED_ID } from '../constants';
+import { selectMenuOverrides } from '../overrides';
+import { NoResults } from '../styled-component';
+import { SELECT_ALL_ID } from '../types';
+import SelectMenuItem from './SelectMenuItem';
+var removeUngroupedIfEmpty = function (groupedOptions) {
+    var _a;
+    if (!((_a = groupedOptions[UNGROUPED_ID]) === null || _a === void 0 ? void 0 : _a.length)) {
+        return _omit(groupedOptions, [UNGROUPED_ID]);
+    }
+    return groupedOptions;
+};
+var SelectMenuAdapter = function (props) {
+    var _a, _b, _c, _d;
+    var id = props.id, groupedItems = props.items, overrides = props.overrides, _e = props.onItemSelect, onItemSelect = _e === void 0 ? _noop : _e, value = props.value, valueKey = props.valueKey, labelKey = props.labelKey, multi = props.multi, selectAllSelected = props.selectAllSelected, noResultsMsg = props.noResultsMsg, captureScroll = props.captureScroll;
+    var selectedValuesSet = useMemo(function () {
+        var set = new Set(_map(value, valueKey));
+        return set;
+    }, [value, valueKey]);
+    /**
+     * extract out useful overrides/props passed by baseui
+     */
+    var listOverride = overrides === null || overrides === void 0 ? void 0 : overrides.List;
+    var optionOverride = overrides === null || overrides === void 0 ? void 0 : overrides.Option;
+    var baseuiMenuListProps;
+    var getItemLabel, baseuiMenuItemProps;
+    if (typeof optionOverride === 'object') {
+        getItemLabel = (_a = optionOverride === null || optionOverride === void 0 ? void 0 : optionOverride.props) === null || _a === void 0 ? void 0 : _a.getItemLabel;
+        baseuiMenuItemProps = (_d = (_c = (_b = optionOverride === null || optionOverride === void 0 ? void 0 : optionOverride.props) === null || _b === void 0 ? void 0 : _b.overrides) === null || _c === void 0 ? void 0 : _c.ListItem) === null || _d === void 0 ? void 0 : _d.props;
+    }
+    if (typeof listOverride === 'object') {
+        baseuiMenuListProps = listOverride.props;
+    }
+    var mergedOverrides = useMemo(function () { return mergeOverrides(selectMenuOverrides, overrides); }, [overrides]);
+    var _f = __read(useOverrides(mergedOverrides.Menu, Menu), 2), MenuOverriden = _f[0], menuProps = _f[1];
+    var _g = __read(useOverrides(mergedOverrides.NoResults, NoResults), 2), NoResultsOverriden = _g[0], noResultsProps = _g[1];
+    var _h = __read(useOverrides(mergedOverrides.Divider, Divider), 2), DividerOverriden = _h[0], dividerProps = _h[1];
+    var menuItemOverrides = useMemo(function () { return ({
+        MenuItem: mergedOverrides.MenuItem,
+        ListItemText: mergedOverrides.ListItemText,
+    }); }, [mergedOverrides.ListItemText, mergedOverrides.MenuItem]);
+    var itemsToRender = _flatten(Object.keys(removeUngroupedIfEmpty(groupedItems)).map(function (itemGroup, index) {
+        var itemsInGroup = groupedItems[itemGroup];
+        var menuItems = itemsInGroup.map(function (item) {
+            var selected = selectedValuesSet.has(item[valueKey]) || (item[SELECT_ALL_ID] && selectAllSelected);
+            return (_jsx(SelectMenuItem, __assign({ overrides: menuItemOverrides, item: item, selected: selected, multi: multi, getItemLabel: getItemLabel, labelKey: labelKey, valueKey: valueKey, onItemSelect: onItemSelect, "$item": item }, baseuiMenuItemProps), item.isCreatable ? 'creatable-option' : item[valueKey]));
+        });
+        if (itemGroup !== UNGROUPED_ID) {
+            menuItems.unshift(_jsx(DividerOverriden, __assign({ first: index === 0 }, dividerProps, { children: _jsx(Typography, __assign({ variant: "l4", weight: "medium", className: "spr-text-03" }, { children: itemGroup }), void 0) }), "divider-".concat(itemGroup)));
+        }
+        return menuItems;
+    }));
+    if (_isEmpty(itemsToRender)) {
+        itemsToRender = (_jsx(NoResultsOverriden, __assign({ "aria-live": "polite", "aria-atomic": true, msg: noResultsMsg, "aria-disabled": true }, noResultsProps), void 0));
+    }
+    return (
+    // focusWhenNavigationEnabled false, or else it will remove focus from select input
+    _jsx(MenuOverriden, __assign({ resetMenuHighlightOnMouseLeave: true, focusWhenNavigationEnabled: false, "$multi": multi, captureScroll: captureScroll, tabIndex: -1, "aria-label": "Menu", role: "listbox" }, baseuiMenuListProps, { id: id }, menuProps, { children: itemsToRender }), void 0));
+};
+export default SelectMenuAdapter;

package/esm/select/selectMenuAdapter/SelectMenuItem.d.ts

@@ -0,0 +1,57 @@
+import * as React from 'react';
+import { ListItemTextProps } from '../../list';
+import { Override } from '../../overrides';
+import { MenuItemProps } from '../../menu';
+import { SelectProps } from '../types';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<MenuItemProps, "selected"> & Pick<SelectProps, "labelKey" | "multi" | "valueKey"> & {
+    item: Record<string, any>;
+    getItemLabel: (item: Record<string, any>) => React.ReactNode;
+    onItemSelect: (item: Record<string, any>) => void;
+    overrides?: {
+        MenuItem?: Override<Omit<import("../../list").ListItemProps, "overrides" | "onMouseEnter" | "onMouseLeave"> & {
+            getChildMenu?: (() => React.ReactElement<any, string | React.JSXElementConstructor<any>> | null) | undefined;
+            onMouseEnter?: (() => void) | undefined;
+            onMouseLeave?: (() => void) | undefined;
+            renderAll?: boolean | undefined;
+            overrides?: {
+                ListItem?: Override<Omit<React.AllHTMLAttributes<HTMLElement>, "style" | "className"> & {
+                    $as?: React.ElementType<any> | undefined;
+                    className?: import("../..").Styles;
+                    style?: import("../..").Styles;
+                } & {
+                    alignItems?: import("../../list").AlignItems | undefined;
+                    autoFocus?: boolean | undefined;
+                    button?: boolean | undefined;
+                    children?: React.ReactNode;
+                    disabled?: boolean | undefined;
+                    endEnhancer?: import("../../list/types").Enhancer<import("../../list").ListItemSharedProps>;
+                    highlighted?: boolean | undefined;
+                    onClick?: ((event: React.MouseEvent<Element, MouseEvent> | React.KeyboardEvent<Element>) => void) | undefined;
+                    overrides?: {
+                        ChildContainer?: Override<import("../../list").ListItemSharedProps & Record<string, any>> | undefined;
+                        EndEnhancer?: Override<import("../../list").ListItemSharedProps & Record<string, any>> | undefined;
+                        Root?: Override<import("../../list").ListItemSharedProps & Record<string, any>> | undefined;
+                        StartEnhancer?: Override<import("../../list").ListItemSharedProps & Record<string, any>> | undefined;
+                    } | undefined;
+                    selected?: boolean | undefined;
+                    startEnhancer?: import("../../list/types").Enhancer<import("../../list").ListItemSharedProps>;
+                } & Record<string, any>> | undefined;
+                Popover?: Override<Omit<import("baseui/popover").PopoverProps, "overrides" | "children"> & {
+                    overrides?: ({
+                        Body?: Override<any> | undefined;
+                        Arrow?: Override<any> | undefined;
+                        Inner?: Override<any> | undefined;
+                    } & {
+                        ArrowTriangle?: Override<any> | undefined;
+                    }) | undefined;
+                    children?: React.ReactNode | ((args: {
+                        isOpen: boolean;
+                    }) => React.ReactNode);
+                    targetElement?: HTMLElement | null | undefined;
+                } & Record<string, any>> | undefined;
+            } | undefined;
+        } & Record<string, any>> | undefined;
+        ListItemText?: Override<ListItemTextProps & Record<string, any>> | undefined;
+    } | undefined;
+} & React.RefAttributes<HTMLElement>>>;
+export default _default;

package/esm/select/selectMenuAdapter/SelectMenuItem.js

@@ -0,0 +1,37 @@
+import { __assign, __read, __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useMemo } from 'react';
+import * as React from 'react';
+import { Checkbox } from '../../checkbox';
+import cx from '../../classNames';
+import { ListItemText } from '../../list';
+import MenuItem from '../../menu/menu-item';
+import { mergeOverrides, useOverrides } from '../../overrides';
+import useUniqueId from '../../hooks/useUniqueId';
+import { SELECT_ALL_ID } from '../types';
+var SelectMenuItem = React.forwardRef(function (_a, ref) {
+    var _b;
+    var item = _a.item, valueKey = _a.valueKey, overrides = _a.overrides, labelKey = _a.labelKey, multi = _a.multi, selected = _a.selected, getItemLabel = _a.getItemLabel, onItemSelect = _a.onItemSelect, restProps = __rest(_a, ["item", "valueKey", "overrides", "labelKey", "multi", "selected", "getItemLabel", "onItemSelect"]);
+    var _c = __read(useOverrides(overrides === null || overrides === void 0 ? void 0 : overrides.MenuItem, MenuItem), 2), MenuItemOverriden = _c[0], menuItemProps = _c[1];
+    var _d = __read(useOverrides(overrides === null || overrides === void 0 ? void 0 : overrides.ListItemText, ListItemText), 2), ListItemTextOverriden = _d[0], listItemTextProps = _d[1];
+    var handleItemSelect = useCallback(function () { return onItemSelect({ item: item }); }, [item, onItemSelect]);
+    var textOverrides = (_b = listItemTextProps) === null || _b === void 0 ? void 0 : _b.overrides;
+    var listItemTextOverrides = useMemo(function () {
+        return mergeOverrides({
+            PrimaryText: { props: { className: cx({ 'font-semibold': item[SELECT_ALL_ID] }) } },
+        }, textOverrides);
+    }, [item, valueKey, textOverrides]);
+    var id = useUniqueId();
+    // Passes intent to override intent from useContextualFormProps,
+    // see: https://prod-gitlab.sprinklr.com/sprinklr/frontend/spaceweb/-/issues/282
+    var startEnhancer = useMemo(function () {
+        return multi && (_jsx(Checkbox, { checked: selected, size: "sm", overrides: { Input: { props: { 'aria-labelledby': id } } }, disabled: item.disabled, intent: "default" }, void 0));
+    }, [multi, selected, item.disabled, item[valueKey], id]);
+    return (_jsx(MenuItemOverriden, __assign({ role: "option", "aria-selected": selected, className: cx({
+            'border-b spr-border-01 border-solid border-t-0 border-l-0 border-r-0': item[SELECT_ALL_ID],
+        }), 
+        // for Multi Select variant do not show selected styles
+        selected: multi ? false : selected, onClick: handleItemSelect, startEnhancer: startEnhancer, disabled: item.disabled, "$multi": multi, "$item": item, "$valueKey": valueKey, "$labelKey": labelKey, ref: ref, id: id }, restProps, menuItemProps, { children: _jsx(ListItemTextOverriden, __assign({ "$multi": multi, "$item": item, "$labelKey": labelKey }, listItemTextProps, { overrides: listItemTextOverrides }, { children: getItemLabel(item) }), void 0) }), void 0));
+});
+SelectMenuItem.displayName = 'SelectMenuItem';
+export default React.memo(SelectMenuItem);

package/esm/select/selectMenuAdapter/index.d.ts

@@ -0,0 +1,2 @@
+import SelectMenuAdapter from './SelectMenuAdapter';
+export default SelectMenuAdapter;

package/esm/select/selectMenuAdapter/index.js

@@ -0,0 +1,2 @@
+import SelectMenuAdapter from './SelectMenuAdapter';
+export default SelectMenuAdapter;

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

@@ -0,0 +1,42 @@
+import * as React from 'react';
+import { StatefulSelectProps } from './types';
+declare function StatefulSelect({ overrides, ...restProps }: StatefulSelectProps): React.ReactElement;
+declare namespace StatefulSelect {
+    var defaultProps: {
+        autoFocus: boolean;
+        backspaceRemoves: boolean;
+        clearable: boolean;
+        closeOnSelect: boolean;
+        creatable: boolean;
+        deleteRemoves: boolean;
+        disabled: boolean;
+        error: boolean;
+        positive: boolean;
+        escapeClearsValue: boolean;
+        filterOptions: any;
+        filterOutSelected: boolean;
+        isLoading: boolean;
+        labelKey: string;
+        maxDropdownHeight: string;
+        multi: boolean;
+        onBlur: (...args: any[]) => void;
+        onBlurResetsInput: boolean;
+        onChange: (...args: any[]) => void;
+        onFocus: (...args: any[]) => void;
+        onInputChange: (...args: any[]) => void;
+        onCloseResetsInput: boolean;
+        onSelectResetsInput: boolean;
+        openOnClick: boolean;
+        startOpen: boolean;
+        options: import("baseui/select").OptionsT;
+        overrides: {};
+        required: boolean;
+        searchable: boolean;
+        size: import("./types").Size;
+        type: "overlay" | import("./types").Type | "mobile";
+        value: import("baseui/select").Value;
+        valueKey: string;
+        placement: "auto" | "bottom" | "left" | "right" | "top" | "topLeft" | "topRight" | "rightTop" | "rightBottom" | "bottomLeft" | "bottomRight" | "leftTop" | "leftBottom" | undefined;
+    };
+}
+export default StatefulSelect;

package/esm/select/stateful-select.js

@@ -0,0 +1,14 @@
+import { __assign, __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { StatefulSelectContainer } from 'baseui/select';
+import OverlaySelect from './overlaySelect';
+import Select from './select';
+import defaultProps from './default-props';
+function StatefulSelect(_a) {
+    var overrides = _a.overrides, restProps = __rest(_a, ["overrides"]);
+    return (_jsx(StatefulSelectContainer, __assign({}, restProps, { children: function (selectProps) {
+            return restProps.type === 'overlay' ? (_jsx(OverlaySelect, __assign({}, selectProps, { overrides: overrides }, { children: restProps.children }), void 0)) : (_jsx(Select, __assign({}, selectProps, { overrides: overrides }), void 0));
+        } }), void 0));
+}
+StatefulSelect.defaultProps = defaultProps;
+export default StatefulSelect;

package/esm/select/styled-component.d.ts

@@ -0,0 +1,18 @@
+import { SelectProps } from 'baseui/select';
+import * as React from 'react';
+import { SharedProps, Size } from './types';
+declare const StyledSelect: React.ComponentType<SelectProps>;
+declare const NoResults: ({ msg, ...props }: {
+    msg?: string | undefined;
+}) => JSX.Element;
+declare const StyledOverlayContentContainer: import("../style/styled").StyledComponent;
+declare const InputContainer: ({ menuId, size, ...props }: SharedProps & {
+    menuId: string;
+    size: Size;
+}) => JSX.Element;
+declare const Input: React.ForwardRefExoticComponent<SharedProps & {
+    id: string;
+    menuId: string;
+} & React.RefAttributes<HTMLInputElement>>;
+export { StyledRoot, StyledClearIcon, StyledControlContainer, StyledDropdownContainer, StyledIconsContainer, StyledInput, StyledInputContainer, StyledInputSizer, StyledPlaceholder, StyledSearchIcon, StyledSearchIconContainer, StyledSelectArrow, StyledSingleValue, StyledValueContainer, } from 'baseui/select';
+export { StyledSelect, NoResults, StyledOverlayContentContainer, InputContainer, Input };

package/esm/select/styled-component.js

@@ -0,0 +1,53 @@
+import { __assign, __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Select as BaseSelect, StyledInputContainer, StyledInput } from 'baseui/select';
+import * as React from 'react';
+import withThemeOverride from '../helpers/baseui/withThemeOverride';
+import { borderRadius } from '../helpers/longHandHelpers';
+import { useLocale } from '../locale';
+import MenuItem from '../menu/menu-item';
+import { styled } from '../style';
+var StyledSelect = withThemeOverride(BaseSelect, function (theme) { return ({
+    borders: {
+        inputBorderRadius: theme.input.borderRadius,
+    },
+    colors: {
+        borderFocus: theme.spr.focus01,
+        contentPrimary: theme.spr.text01,
+        contentSecondary: theme.spr.text03,
+        inputBorder: theme.spr.field,
+        inputFill: theme.spr.ui01,
+        inputFillError: theme.spr.ui01,
+        inputFillDisabled: theme.spr.ui02,
+        inputFillActive: theme.spr.ui01,
+        inputFillPositive: theme.spr.ui01,
+        inputTextDisabled: theme.spr.text02,
+        inputPlaceholder: theme.spr.textPlaceholder,
+        inputBorderError: theme.spr.supportError,
+        inputBorderPositive: theme.spr.supportSuccess,
+        inputEnhancerFill: theme.spr.icon03,
+        inputEnhancerFillDisabled: theme.spr.iconDisable,
+        inputEnhancerTextDisabled: theme.spr.text02,
+    },
+}); });
+var NoResults = function (_a) {
+    var msg = _a.msg, props = __rest(_a, ["msg"]);
+    var locale = useLocale();
+    return (_jsx(MenuItem, __assign({ button: false }, props, { children: msg || locale.select.noResultsMsg }), void 0));
+};
+var DEFAULT_OVERLAY_WIDTH = '300px';
+var StyledOverlayContentContainer = styled('div', 'overflow-auto', function (_a, _b) {
+    var px2rem = _a.px2rem;
+    var $overlayWidth = _b.$overlayWidth;
+    return (__assign({ width: $overlayWidth || DEFAULT_OVERLAY_WIDTH }, borderRadius('inherit')));
+});
+var InputContainer = function (_a) {
+    var menuId = _a.menuId, size = _a.size, props = __rest(_a, ["menuId", "size"]);
+    return (_jsx(StyledInputContainer, __assign({}, props, { "$selectSize": size, role: props.$searchable ? null : 'combobox', "aria-haspopup": props.$searchable ? null : 'listbox', "aria-owns": !props.$searchable && props.$isOpen ? menuId : null }), void 0));
+};
+var Input = React.forwardRef(function (_a, ref) {
+    var id = _a.id, menuId = _a.menuId, props = __rest(_a, ["id", "menuId"]);
+    return (_jsx(StyledInput, __assign({}, props, { id: id, "aria-controls": props.$searchable && props.$isOpen ? menuId : null, ref: ref }), void 0));
+});
+export { StyledRoot, StyledClearIcon, StyledControlContainer, StyledDropdownContainer, StyledIconsContainer, StyledInput, StyledInputContainer, StyledInputSizer, StyledPlaceholder, StyledSearchIcon, StyledSearchIconContainer, StyledSelectArrow, StyledSingleValue, StyledValueContainer, } from 'baseui/select';
+export { StyledSelect, NoResults, StyledOverlayContentContainer, InputContainer, Input };

package/esm/select/types.d.ts

@@ -0,0 +1,91 @@
+import * as React from 'react';
+import { DropdownOverrides as BaseuiDropdownOverrides, DropdownProps as BaseDropdownProps, OnChangeParams as BaseOnChangeParams, Option, OptionsT, SelectOverrides as BaseuiSelectOverrides, SelectProps as BaseuiSelectProps, State, StateReducer } from 'baseui/select';
+import { STATE_CHANGE_TYPE } from './constants';
+import { Override } from '../overrides';
+import { TagProps } from '../tag';
+import { Intent, SpacewebComponentProps } from '../types';
+import { PopoverProps } from '../popover/types';
+import { ValueOf } from '../utility-types';
+export declare type Size = 'sm' | 'md' | 'lg';
+export declare type Type = 'select' | 'search';
+declare type OverridableComponent = keyof Omit<BaseuiSelectOverrides, 'Dropdown' | 'DropdownListItem' | 'DropdownOption'> | 'Menu' | 'MenuItem' | 'NoResults' | 'Divider' | 'ListItemText' | 'OverlayContentContainer';
+export declare type SelectActions = {
+    setDropdownOpen?: (shouldOpen: boolean) => void;
+};
+export declare type BaseSelectProps = SpacewebComponentProps<Omit<BaseuiSelectProps, 'overrides' | 'size' | 'type' | 'onChange' | 'positive' | 'error'>> & {
+    onChange?: (params: OnChangeParams) => unknown;
+    intent?: Intent;
+    overrides?: {
+        [key in OverridableComponent]?: Override<any>;
+    };
+    type?: Type;
+    hideSelectAll?: boolean;
+    size?: Size;
+    captureScroll?: boolean;
+    placement?: PopoverProps['placement'];
+    popoverMinWidth?: string;
+    methodsRef?: React.MutableRefObject<SelectActions>;
+    createOption?: (label: string) => OptionsT | Promise<OptionsT>;
+    onPaste?: (event: React.ClipboardEvent) => OptionsT | undefined;
+};
+declare type Merge<A, B> = Omit<A, keyof B> & B;
+export declare type OverlaySelectProps = Merge<BaseSelectProps, {
+    type: 'overlay';
+    overlayWidth?: string;
+    children: PopoverProps['children'];
+}>;
+export declare type MobileSelectProps = Merge<OverlaySelectProps, {
+    type: 'mobile';
+    children?: React.ReactNode;
+    label?: React.ReactNode;
+}>;
+export declare type SelectProps = BaseSelectProps | OverlaySelectProps | MobileSelectProps;
+export declare type StatefulSelectProps = SelectProps & {
+    initialState?: State;
+    stateReducer?: StateReducer;
+};
+export declare type SharedProps = {
+    $clearable?: boolean;
+    $creatable?: boolean;
+    $disabled?: boolean;
+    $intent?: Intent;
+    $isFocused?: boolean;
+    $isLoading?: boolean;
+    $isOpen?: boolean;
+    $isPseudoFocused?: boolean;
+    $multi?: boolean;
+    $required?: boolean;
+    $searchable?: boolean;
+    $type?: Type;
+    $width?: string;
+    $maxHeight?: string;
+    $isHighlighted?: boolean;
+    $selected?: boolean;
+    $isEmpty?: boolean;
+    $size?: Size;
+};
+export declare type DropdownProps = Omit<BaseDropdownProps, 'overrides' | 'size' | 'type'> & {
+    overrides?: {
+        [key in keyof BaseuiDropdownOverrides]?: Override<any>;
+    };
+    type?: Type;
+};
+export declare type OnChangeParams = BaseOnChangeParams & {
+    type?: ValueOf<typeof STATE_CHANGE_TYPE>;
+};
+export declare const SELECT_ALL_ID = "__selectAll";
+declare type RemoveValue = () => void;
+export declare type MultiValueProps = Omit<TagProps, 'overrides'> & SharedProps & {
+    value: Option;
+    removeValue: RemoveValue;
+    selectSize: Size;
+    overrides?: {
+        Tag?: Override<{
+            variant: 'light';
+            intent: 'default';
+            className: string;
+            onActionClick: RemoveValue;
+        } & Record<string, any>>;
+    };
+};
+export type { TYPE, Option, Value, OptionsT, OptgroupsT, StateReducer, AutosizeInputProps, StatefulContainerProps, SelectState, AutosizeInputState, State as StatefulContainerState, } from 'baseui/select';

package/esm/select/types.js

@@ -0,0 +1 @@
+export var SELECT_ALL_ID = '__selectAll';

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

@@ -0,0 +1 @@
+export { default as filterOptions } from 'baseui/select/utils/default-filter-options';

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

@@ -0,0 +1,2 @@
+// todo: no deep import
+export { default as filterOptions } from 'baseui/select/utils/default-filter-options';