@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/baseui/radio/radiogroup.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+/*
+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 overrides_1 = require("../helpers/overrides");
+var styled_components_1 = require("./styled-components");
+var focusVisible_1 = require("../utils/focusVisible");
+var StatelessRadioGroup = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(StatelessRadioGroup, _super);
+    function StatelessRadioGroup() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.state = { isFocusVisible: false, focusedRadioIndex: -1 };
+        _this.handleFocus = function (event, index) {
+            if ((0, focusVisible_1.isFocusVisible)(event)) {
+                _this.setState({ isFocusVisible: true });
+            }
+            _this.setState({ focusedRadioIndex: index });
+            _this.props.onFocus && _this.props.onFocus(event);
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _this.handleBlur = function (event, index) {
+            if (_this.state.isFocusVisible !== false) {
+                _this.setState({ isFocusVisible: false });
+            }
+            _this.setState({ focusedRadioIndex: -1 });
+            _this.props.onBlur && _this.props.onBlur(event);
+        };
+        return _this;
+    }
+    StatelessRadioGroup.prototype.render = function () {
+        var _this = this;
+        var _a = this.props.overrides, overrides = _a === void 0 ? {} : _a;
+        var _b = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.RadioGroupRoot, styled_components_1.RadioGroupRoot), 2), RadioGroupRoot = _b[0], radioGroupRootProps = _b[1];
+        return ((0, jsx_runtime_1.jsx)(RadioGroupRoot, (0, tslib_1.__assign)({ id: this.props.id, role: "radiogroup", "aria-describedby": this.props['aria-describedby'], "aria-errormessage": this.props['aria-errormessage'], "aria-invalid": this.props.error || null, "aria-label": this.props['aria-label'], "aria-labelledby": this.props['aria-labelledby'], "$align": this.props.align, "$disabled": this.props.disabled, "$error": this.props.error, "$required": this.props.required }, radioGroupRootProps, { children: React.Children.map(this.props.children, function (child, index) {
+                if (!React.isValidElement(child)) {
+                    return null;
+                }
+                var checked = _this.props.value === child.props.value;
+                return React.cloneElement(child, {
+                    //@ts-ignore
+                    align: _this.props.align,
+                    autoFocus: _this.props.autoFocus,
+                    checked: checked,
+                    disabled: _this.props.disabled || child.props.disabled,
+                    error: _this.props.error,
+                    isFocused: _this.state.focusedRadioIndex === index,
+                    isFocusVisible: _this.state.isFocusVisible,
+                    tabIndex: (index === 0 && !_this.props.value) || checked ? '0' : '-1',
+                    labelPlacement: _this.props.labelPlacement,
+                    name: _this.props.name,
+                    onBlur: function (e) { return _this.handleBlur(e, index); },
+                    onFocus: function (e) { return _this.handleFocus(e, index); },
+                    onChange: _this.props.onChange,
+                    onMouseEnter: _this.props.onMouseEnter,
+                    onMouseLeave: _this.props.onMouseLeave,
+                });
+            }) }), void 0));
+    };
+    StatelessRadioGroup.defaultProps = {
+        name: '',
+        value: '',
+        disabled: false,
+        autoFocus: false,
+        labelPlacement: 'right',
+        align: 'vertical',
+        error: false,
+        required: false,
+        onChange: function () { },
+        onMouseEnter: function () { },
+        onMouseLeave: function () { },
+        onFocus: function () { },
+        onBlur: function () { },
+        overrides: {},
+    };
+    return StatelessRadioGroup;
+}(React.Component));
+exports.default = StatelessRadioGroup;

package/baseui/radio/stateful-radiogroup-container.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { StatefulContainerProps, DefaultStatefulProps, State } from './types';
+import type { ChangeEvent } from 'react';
+declare class StatefulRadioGroupContainer extends React.Component<StatefulContainerProps, State> {
+    static defaultProps: DefaultStatefulProps;
+    constructor(props: StatefulContainerProps);
+    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    stateReducer: (type: string, e: ChangeEvent<HTMLInputElement>) => void;
+    render(): React.ReactNode;
+}
+export default StatefulRadioGroupContainer;

package/baseui/radio/stateful-radiogroup-container.js

@@ -0,0 +1,58 @@
+"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 constants_1 = require("./constants");
+var defaultStateReducer = function (type, nextState) { return nextState; };
+var StatefulRadioGroupContainer = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(StatefulRadioGroupContainer, _super);
+    function StatefulRadioGroupContainer(props) {
+        var _this = _super.call(this, props) || this;
+        _this.onChange = function (e) {
+            _this.stateReducer(constants_1.STATE_TYPE.change, e);
+            var onChange = _this.props.onChange;
+            onChange && onChange(e);
+        };
+        _this.stateReducer = function (type, e) {
+            var nextState = {};
+            var stateReducer = _this.props.stateReducer;
+            if (type === constants_1.STATE_TYPE.change) {
+                nextState = { value: e.target.value };
+            }
+            var newState = stateReducer(type, nextState, _this.state, e);
+            _this.setState(newState);
+        };
+        var initialState = _this.props.initialState;
+        _this.state = (0, tslib_1.__assign)({}, initialState);
+        return _this;
+    }
+    StatefulRadioGroupContainer.prototype.render = function () {
+        var _a = this.props, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _b = _a.children, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        children = _b === void 0 ? function (childProps) { return null; } : _b, // eslint-disable-line no-unused-vars
+        // 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"]);
+        var onChange = this.onChange;
+        return children((0, tslib_1.__assign)((0, tslib_1.__assign)({}, restProps), { value: this.state.value, onChange: onChange }));
+    };
+    StatefulRadioGroupContainer.defaultProps = {
+        initialState: {
+            value: '',
+        },
+        stateReducer: defaultStateReducer,
+        onChange: function () { },
+    };
+    return StatefulRadioGroupContainer;
+}(React.Component));
+exports.default = StatefulRadioGroupContainer;

package/baseui/radio/stateful-radiogroup.d.ts

@@ -0,0 +1,6 @@
+import type { RadioGroupProps, StatefulRadioGroupProps } from './types';
+declare const StatefulRadioGroup: {
+    (props: StatefulRadioGroupProps & Omit<RadioGroupProps, keyof StatefulRadioGroupProps>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default StatefulRadioGroup;

package/baseui/radio/stateful-radiogroup.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+// eslint-disable-next-line import/no-named-default
+var stateful_radiogroup_container_1 = (0, tslib_1.__importDefault)(require("./stateful-radiogroup-container"));
+// eslint-disable-next-line import/no-named-default
+var radiogroup_1 = (0, tslib_1.__importDefault)(require("./radiogroup"));
+// Styled elements
+var StatefulRadioGroup = function (props) {
+    var children = props.children, restProps = (0, tslib_1.__rest)(props, ["children"]);
+    return ((0, jsx_runtime_1.jsx)(stateful_radiogroup_container_1.default, (0, tslib_1.__assign)({}, restProps, { children: function (childrenProps) { return (0, jsx_runtime_1.jsx)(radiogroup_1.default, (0, tslib_1.__assign)({}, childrenProps, { children: children }), void 0); } }), void 0));
+};
+StatefulRadioGroup.displayName = 'StatefulRadioGroup';
+exports.default = StatefulRadioGroup;

package/baseui/radio/styled-components.d.ts

@@ -0,0 +1,7 @@
+export declare const RadioGroupRoot: import("../../style/styled").StyledComponent;
+export declare const Root: import("../../style/styled").StyledComponent;
+export declare const RadioMarkInner: import("../../style/styled").StyledComponent;
+export declare const RadioMarkOuter: import("../../style/styled").StyledComponent;
+export declare const Label: import("../../style/styled").StyledComponent;
+export declare const Input: import("../../style/styled").StyledComponent;
+export declare const Description: import("../../style/styled").StyledComponent;

package/baseui/radio/styled-components.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Description = exports.Input = exports.Label = exports.RadioMarkOuter = exports.RadioMarkInner = exports.Root = exports.RadioGroupRoot = void 0;
+/*
+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");
+function getLabelColor(utils, props) {
+    var theme = utils.theme;
+    var $disabled = props.$disabled;
+    return $disabled ? theme.spr.text02 : theme.spr.text01;
+}
+exports.RadioGroupRoot = (0, style_1.styled)('div', 'flex flex-wrap', function (utils, props) {
+    var $disabled = props.$disabled, $align = props.$align;
+    return {
+        flexDirection: $align === 'horizontal' ? 'row' : 'column',
+        alignItems: $align === 'horizontal' ? 'center' : 'flex-start',
+        cursor: $disabled ? 'not-allowed' : 'default',
+        '-webkit-tap-highlight-color': 'transparent',
+    };
+});
+exports.RadioGroupRoot.displayName = 'RadioGroupRoot';
+// @ts-ignore
+exports.Root = (0, style_1.styled)('label', 'flex items-center', function (utils, props) {
+    var $disabled = props.$disabled, $labelPlacement = props.$labelPlacement;
+    return {
+        flexDirection: $labelPlacement === 'top' || $labelPlacement === 'bottom' ? 'column' : 'row',
+        cursor: $disabled ? 'not-allowed' : 'pointer',
+        width: 'fit-content',
+    };
+});
+exports.Root.displayName = 'Root';
+exports.RadioMarkInner = (0, style_1.styled)('div', 'rounded-full');
+exports.RadioMarkInner.displayName = 'RadioMarkInner';
+exports.RadioMarkOuter = (0, style_1.styled)('div', 'items-center rounded-full flex justify-center align-middle m-0.5 flex-shrink-0', {
+    outline: 'none',
+});
+exports.RadioMarkOuter.displayName = 'RadioMarkOuter';
+exports.Label = (0, style_1.styled)('div', 'align-middle font-500 leading-8', function (utils, props) { return ({
+    color: getLabelColor(utils, props),
+}); });
+exports.Label.displayName = 'Label';
+exports.Input = (0, style_1.styled)('input', 'absolute', {
+    clip: 'rect(0 0 0 0)',
+});
+exports.Input.displayName = 'Input';
+exports.Description = (0, style_1.styled)('div', 'cursor-auto ', {
+    maxWidth: '240px',
+});
+exports.Description.displayName = 'Description';

package/baseui/radio/types.d.ts

@@ -0,0 +1,169 @@
+import type * as React from 'react';
+import type { Override } from '../helpers/overrides';
+import type { ALIGN } from './constants';
+export declare type LabelPlacement = 'top' | 'right' | 'bottom' | 'left';
+export declare type Align = keyof typeof ALIGN;
+export declare type RadioOverrides = {
+    RadioMarkInner?: Override;
+    RadioMarkOuter?: Override;
+    Label?: Override;
+    Root?: Override;
+    Input?: Override;
+    Description?: Override;
+};
+export declare type RadioGroupOverrides = {
+    RadioGroupRoot?: Override;
+};
+export declare type DefaultProps = Partial<RadioGroupProps>;
+export declare type RadioGroupProps = {
+    /** Id of element which contains a related caption */
+    'aria-describedby'?: string;
+    /** Id of element which contains a related error message */
+    'aria-errormessage'?: string;
+    /**
+     * Used to define a string that labels the radio group. Use this prop if the label is not
+     * visible on screen. If the label is visible, use the 'aria-labeledby' prop instead.
+     */
+    'aria-label'?: string;
+    /**
+     * Establishes a relationship between the radio group and its label. Screen readers use this
+     * attribute to catalog the object on a page so that users can navigate between them.
+     */
+    'aria-labelledby'?: string;
+    overrides?: RadioGroupOverrides;
+    /** As `children` in React native approach represents radio buttons inside of Radio Group. Can use `Radio` from this package. */
+    children?: Array<React.ReactNode>;
+    /** The value of radio button, which is preselected. */
+    value?: string;
+    /** Disabled all radio group from being changed. To disable some of radios provide disabled flag in each of them. */
+    disabled?: boolean;
+    /** Set if the control is required to be checked. */
+    required?: boolean;
+    /** Sets radio group into error state. */
+    error?: boolean;
+    /** Set to be focused (active) on selected\checked radio. */
+    autoFocus?: boolean;
+    /** How to position radio buttons in the group. */
+    align?: Align;
+    /** String value for the name of RadioGroup, it is used to group buttons. If missed default is random ID string. */
+    name?: string;
+    /** How to position the label relative to the radio itself. */
+    labelPlacement?: LabelPlacement;
+    /** Unique id for RadioGroup, help ARIA to identify element */
+    id?: string;
+    /** Handler for change events on trigger element. */
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for mouseenter events on trigger element. */
+    onMouseEnter?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for mouseleave events on trigger element. */
+    onMouseLeave?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for focus events on trigger element. */
+    onFocus?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for blur events on trigger element. */
+    onBlur?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+};
+export declare type State = {
+    value?: string;
+};
+export declare type RadioProps = {
+    /** Focus the radio on initial render. */
+    autoFocus?: boolean;
+    /** How the radio will be displayed along with its description. Controls spacing */
+    align?: Align;
+    /** Check or uncheck the control. */
+    checked?: boolean;
+    /** Label of radio. */
+    children?: React.ReactNode;
+    /** Indicates if this radio children contain an interactive element (prevents the label from moving focus from the child element to the radio button) */
+    containsInteractiveElement?: boolean;
+    /** Add more detail about a radio element. */
+    description?: string;
+    /** Disable the checkbox from being changed. */
+    disabled?: boolean;
+    /** Used to get a ref to the input element. Useful for programmatically focusing the input */
+    inputRef?: React.RefObject<HTMLInputElement>;
+    /** Renders checkbox in errored state. */
+    error?: boolean;
+    /** Is radio focused / active? */
+    isFocused?: boolean;
+    /** Is parent RadioGroup focused by keyboard? */
+    isFocusVisible?: boolean;
+    /** How to position the label relative to the checkbox itself. */
+    labelPlacement?: 'top' | 'right' | 'bottom' | 'left';
+    /** Passed to the input element name attribute */
+    name?: string;
+    /** handler for blur events on trigger element. */
+    onBlur?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for change events on trigger element. */
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** handler for focus events on trigger element. */
+    onFocus?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for mouseenter events on trigger element. */
+    onMouseEnter?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for mouseleave events on trigger element. */
+    onMouseLeave?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for mousedown events on trigger element. */
+    onMouseDown?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Handler for mouseup events on trigger element. */
+    onMouseUp?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    overrides?: RadioOverrides;
+    /** Marks the checkbox as required. */
+    required?: boolean;
+    /** Passed to the input element value attribute */
+    value?: string;
+    /** Passed to the input element, typically managed by RadioGroup */
+    tabIndex?: string;
+};
+export declare type RadioState = {
+    isActive: boolean;
+    isHovered: boolean;
+};
+export declare type StateReducer = (stateType: string, nextState: State, currentState: State, event: React.ChangeEvent<HTMLInputElement>) => State;
+export declare type StatelessState = {
+    isFocusVisible: boolean;
+    focusedRadioIndex: number;
+};
+export declare type DefaultStatefulProps = {
+    initialState: State;
+    children?: (props: RadioGroupProps) => React.ReactNode;
+    stateReducer: StateReducer;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+};
+export declare type StatefulContainerProps = {
+    overrides?: RadioGroupOverrides;
+    /** Should return `RadioGroup` instance with standard or customized inner elements. */
+    children?: (props: RadioGroupProps) => React.ReactNode;
+    /** Initial state populated into the component */
+    initialState?: State;
+    /** Reducer function to manipulate internal state updates. */
+    stateReducer: StateReducer;
+    /** Handler for change events on trigger element. */
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+    /** Set to be focused (active) on selected\checked radio. */
+    autoFocus?: boolean;
+};
+export declare type StatefulRadioGroupProps = {
+    overrides?: RadioGroupOverrides;
+    /** A list of `Radio` components. */
+    children?: Array<React.ReactNode>;
+    /** Initial state populated into the component */
+    initialState?: State;
+    /** Set to be focused (active) on selected\checked radio. */
+    autoFocus?: boolean;
+    /** Handler for change events on trigger element. */
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => unknown;
+};
+export declare type StyleProps = {
+    $align?: string;
+    $checked: boolean;
+    $disabled: boolean;
+    $hasDescription: boolean;
+    $isActive: boolean;
+    $error: boolean;
+    $isFocused: boolean;
+    $isFocusVisible: boolean;
+    $isHovered: boolean;
+    $labelPlacement: LabelPlacement;
+    $required: boolean;
+    $value: string;
+};

package/baseui/radio/types.js

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

package/baseui/select/autosize-input.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { StyledInput } from './styled-components';
+import type { AutosizeInputProps, AutosizeInputState } from './types';
+import type { ComponentProps } from 'react';
+export default class AutosizeInput extends React.Component<AutosizeInputProps & Omit<ComponentProps<typeof StyledInput>, keyof AutosizeInputProps>, AutosizeInputState> {
+    mounted: boolean;
+    sizer: HTMLElement | undefined | null;
+    static defaultProps: {
+        inputRef: {
+            current: HTMLInputElement | null;
+        };
+        value: string;
+        overrides: {};
+    };
+    state: {
+        inputWidth: number;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: AutosizeInputProps, prevState: AutosizeInputState): void;
+    componentWillUnmount(): void;
+    sizerRef: (el?: HTMLElement | null | undefined) => void;
+    updateInputWidth(): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/baseui/select/autosize-input.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var jsx_runtime_1 = require("react/jsx-runtime");
+/*
+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 styled_components_1 = require("./styled-components");
+var overrides_1 = require("../helpers/overrides");
+var AutosizeInput = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(AutosizeInput, _super);
+    function AutosizeInput() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.state = {
+            inputWidth: 5,
+        };
+        _this.sizerRef = function (el) {
+            _this.sizer = el;
+        };
+        return _this;
+    }
+    AutosizeInput.prototype.componentDidMount = function () {
+        this.mounted = true;
+        this.updateInputWidth();
+    };
+    AutosizeInput.prototype.componentDidUpdate = function (prevProps, prevState) {
+        this.updateInputWidth();
+    };
+    AutosizeInput.prototype.componentWillUnmount = function () {
+        this.mounted = false;
+    };
+    AutosizeInput.prototype.updateInputWidth = function () {
+        if (!this.mounted || !this.sizer || typeof this.sizer.scrollWidth === 'undefined') {
+            return;
+        }
+        var newInputWidth = this.sizer.scrollWidth + 2;
+        if (newInputWidth !== this.state.inputWidth &&
+            this.sizer.scrollWidth !== this.state.inputWidth) {
+            this.setState({ inputWidth: newInputWidth });
+        }
+    };
+    AutosizeInput.prototype.render = function () {
+        var _a = this.props, _b = _a.overrides, overrides = _b === void 0 ? {} : _b, inputRef = _a.inputRef, restProps = (0, tslib_1.__rest)(_a, ["overrides", "inputRef"]);
+        var _c = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.Input, styled_components_1.StyledInput), 2), Input = _c[0], inputProps = _c[1];
+        var sizerValue = [this.props.defaultValue, this.props.value, ''].reduce(function (previousValue, currentValue) {
+            if (previousValue !== null && previousValue !== undefined) {
+                return previousValue;
+            }
+            return currentValue;
+        });
+        var componentInputProps = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, restProps), { $width: "".concat(this.state.inputWidth, "px") });
+        return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(Input, (0, tslib_1.__assign)({}, componentInputProps, { ref: inputRef }, inputProps), void 0), (0, jsx_runtime_1.jsx)(styled_components_1.StyledInputSizer, (0, tslib_1.__assign)({ "$size": this.props.$size, 
+                    // @ts-ignore
+                    ref: this.sizerRef, "$style": inputProps.$style ? inputProps.$style : null }, { children: sizerValue }), void 0)] }, void 0));
+    };
+    AutosizeInput.defaultProps = {
+        inputRef: React.createRef(),
+        value: '',
+        overrides: {},
+    };
+    return AutosizeInput;
+}(React.Component));
+exports.default = AutosizeInput;

package/baseui/select/constants.d.ts

@@ -0,0 +1,13 @@
+export { SIZE } from '../input';
+export declare const TYPE: {
+    readonly select: "select";
+    readonly search: "search";
+};
+export declare const STATE_CHANGE_TYPE: Readonly<{
+    readonly select: "select";
+    readonly remove: "remove";
+    readonly clear: "clear";
+    readonly inputChange: "inputChange";
+    readonly selectAll: "selectAll";
+}>;
+export declare const SELECT_ALL_ID = "__selectAll";

package/baseui/select/constants.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SELECT_ALL_ID = exports.STATE_CHANGE_TYPE = exports.TYPE = exports.SIZE = void 0;
+/*
+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 input_1 = require("../input");
+Object.defineProperty(exports, "SIZE", { enumerable: true, get: function () { return input_1.SIZE; } });
+exports.TYPE = {
+    select: 'select',
+    search: 'search',
+};
+exports.STATE_CHANGE_TYPE = Object.freeze({
+    select: 'select',
+    remove: 'remove',
+    clear: 'clear',
+    inputChange: 'inputChange',
+    selectAll: 'selectAll',
+});
+exports.SELECT_ALL_ID = '__selectAll';

package/baseui/select/default-props.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="react" />
+declare const 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?: import("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?: import("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 defaultProps;