@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/baseui/timepicker/timepicker.js

@@ -0,0 +1,260 @@
+"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 locale_1 = require("../locale");
+var select_1 = require("../select");
+var date_helpers_1 = (0, tslib_1.__importDefault)(require("../datepicker/utils/date-helpers"));
+var date_fns_adapter_1 = (0, tslib_1.__importDefault)(require("../datepicker/utils/date-fns-adapter"));
+var MINUTE = 60;
+var HOUR = MINUTE * 60;
+var DAY = HOUR * 24;
+var NOON = DAY / 2;
+var TimePicker = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(TimePicker, _super);
+    function TimePicker(props) {
+        var _this = _super.call(this, props) || this;
+        // @ts-ignore
+        _this.state = { steps: [], value: null };
+        _this.onChange = function (params) {
+            _this.setState({ value: params.value[0] });
+            if (params.value.length === 0) {
+                if (_this.props.nullable) {
+                    _this.props.onChange && _this.props.onChange(null);
+                }
+                return;
+            }
+            var seconds = typeof params.value[0].id === 'string' ? parseInt(params.value[0].id, 10) : params.value[0].id || 0;
+            _this.handleChange(seconds);
+        };
+        _this.secondsToLabel = function (seconds, format) {
+            var _a = (0, tslib_1.__read)(_this.dateHelpers.secondsToHourMinute(seconds), 2), hours = _a[0], minutes = _a[1];
+            // @ts-ignore
+            var zeroPrefix = function (n) { return (n < 10 ? "0".concat(n) : n); };
+            if (format === '12') {
+                var isAfterNoon = seconds >= NOON;
+                if (isAfterNoon) {
+                    hours -= 12;
+                }
+                if (hours === 0) {
+                    hours = 12;
+                }
+                return "".concat(hours, ":").concat(zeroPrefix(minutes), " ").concat(isAfterNoon ? 'PM' : 'AM');
+            }
+            return "".concat(zeroPrefix(hours), ":").concat(zeroPrefix(minutes));
+        };
+        /**
+         * Converts a time string, e.g. 10:00, to one or more possible TimePicker
+         * options representing that time.
+         */
+        _this.stringToOptions = function (str, format) {
+            if (format === void 0) { format = '12'; }
+            // leading zero is optional, AM/PM is optional
+            var twelveHourRegex = /^(1[0-2]|0?[1-9]):([0-5][0-9]) ?([AaPp][Mm]?)?$/;
+            // leading zero is optional
+            var twentyFourHourRegex = /^([0-9]|0[0-9]|1[0-9]|2[0-3]):([0-5][0-9])$/;
+            var regex = format === '12' ? twelveHourRegex : twentyFourHourRegex;
+            var match = str.match(regex);
+            if (!match) {
+                return [];
+            }
+            var hours = Number(match[1]);
+            var minutes = Number(match[2]);
+            var hoursMinutes = [];
+            switch (format) {
+                case '24': {
+                    // @ts-ignore
+                    hoursMinutes = [{ hours: hours, minutes: minutes }];
+                    break;
+                }
+                case '12':
+                default: {
+                    var twelveHours = hours % 12;
+                    var meridiem = match[3];
+                    // if there's no AM/PM, add both AM and PM options
+                    if (!meridiem) {
+                        hoursMinutes = [
+                            // @ts-ignore
+                            { hours: twelveHours, minutes: minutes },
+                            // @ts-ignore
+                            { hours: twelveHours + 12, minutes: minutes },
+                        ];
+                    }
+                    else {
+                        var twentyFourHours = meridiem.toLowerCase()[0] === 'a' ? twelveHours : twelveHours + 12;
+                        // @ts-ignore
+                        hoursMinutes = [{ hours: twentyFourHours, minutes: minutes }];
+                    }
+                    break;
+                }
+            }
+            return hoursMinutes.map(function (_a) {
+                var hours = _a.hours, minutes = _a.minutes;
+                var secs = hours * 3600 + minutes * 60;
+                return { id: secs, label: _this.secondsToLabel(secs, format) };
+            });
+        };
+        _this.handleChange = function (seconds) {
+            var _a = (0, tslib_1.__read)(_this.dateHelpers.secondsToHourMinute(seconds), 2), hours = _a[0], minutes = _a[1];
+            var updatedDate = _this.setTime(_this.props.value, hours, minutes, 0);
+            _this.props.onChange && _this.props.onChange(updatedDate);
+        };
+        _this.setTime = function (val, hours, minutes, seconds) {
+            var _a = _this.dateHelpers, setSeconds = _a.setSeconds, setMinutes = _a.setMinutes, setHours = _a.setHours;
+            var date = _this.props.adapter.startOfDay(_this.props.adapter.date(val || undefined));
+            return setSeconds(setMinutes(setHours(date, hours), minutes), seconds);
+        };
+        _this.getTimeWindowInSeconds = function (
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        step) {
+            var _a = _this.props, min = _a.minTime, max = _a.maxTime, ignoreMinMaxDateComponent = _a.ignoreMinMaxDateComponent;
+            var dayStart = _this.setTime(_this.props.value, 0, 0, 0);
+            var dayEnd = _this.setTime(_this.props.value, 24, 0, 0);
+            if (!min || (_this.props.adapter.isBefore(min, dayStart) && !ignoreMinMaxDateComponent)) {
+                min = dayStart;
+            }
+            else {
+                min = _this.setTime(_this.props.value, _this.props.adapter.getHours(min), _this.props.adapter.getMinutes(min), _this.props.adapter.getSeconds(min));
+            }
+            if (!max || (_this.props.adapter.isAfter(max, dayEnd) && !ignoreMinMaxDateComponent)) {
+                max = dayEnd;
+            }
+            else {
+                max = _this.setTime(_this.props.value, _this.props.adapter.getHours(max), _this.props.adapter.getMinutes(max), 
+                // maxTime (if provided) should be inclusive, so add an extra second here
+                _this.props.adapter.getSeconds(max) + 1);
+            }
+            var minDate = _this.props.adapter.toJsDate(min);
+            var maxDate = _this.props.adapter.toJsDate(max);
+            var midnightDate = _this.props.adapter.toJsDate(dayStart);
+            return {
+                // @ts-expect-error todo(flow->ts)
+                start: (minDate - midnightDate) / 1000,
+                // @ts-expect-error todo(flow->ts)
+                end: (maxDate - midnightDate) / 1000,
+            };
+        };
+        _this.buildSteps = function () {
+            var _a = _this.props.step, step = _a === void 0 ? 900 : _a;
+            var timeWindow = _this.getTimeWindowInSeconds(step);
+            var stepCount = (timeWindow.end - timeWindow.start) / step;
+            if (process.env.NODE_ENV !== 'production' && stepCount > 500) {
+                // eslint-disable-next-line no-console
+                console.warn("Provided step value (".concat(step, ") results in ").concat(stepCount, " steps. Performance may suffer when more than 500 elements are rendered."));
+            }
+            if (!Number.isInteger(stepCount)) {
+                var previousStepCount = stepCount;
+                stepCount = Math.round(stepCount);
+                if (process.env.NODE_ENV !== 'production') {
+                    // eslint-disable-next-line no-console
+                    console.warn("Provided step value (".concat(step, ") does not spread evenly across a day. Rounding from ").concat(previousStepCount, " total steps to ").concat(stepCount, "."));
+                }
+            }
+            var options = [];
+            for (var i = timeWindow.start; i < timeWindow.end; i += step) {
+                // @ts-ignore
+                options.push(i);
+            }
+            return options;
+        };
+        _this.creatableFilterOptions = function (options, filterValue, excludeOptions, newProps) {
+            var result = _this.stringToOptions(filterValue, _this.props.format);
+            if (result.length) {
+                return result;
+            }
+            return (0, select_1.filterOptions)(options, filterValue, excludeOptions, newProps);
+        };
+        _this.buildSelectedOption = function (value, format) {
+            if (format === void 0) { format = '12'; }
+            var secs = _this.dateHelpers.dateToSeconds(value);
+            return {
+                id: secs,
+                label: _this.secondsToLabel(secs, format || '12'),
+            };
+        };
+        _this.dateHelpers = new date_helpers_1.default(props.adapter);
+        return _this;
+    }
+    TimePicker.prototype.componentDidMount = function () {
+        var steps = this.buildSteps();
+        if (this.props.value && this.props.adapter.isValid(this.props.value)) {
+            this.setState({
+                steps: steps,
+                value: this.buildSelectedOption(this.props.value, this.props.format),
+            });
+        }
+        else {
+            var seconds_1 = this.dateHelpers.dateToSeconds(this.props.adapter.date());
+            var closestStep_1 = NOON;
+            steps.forEach(function (step) {
+                if (Math.abs(step - seconds_1) < Math.abs(closestStep_1 - seconds_1)) {
+                    closestStep_1 = step;
+                }
+            });
+            this.setState({
+                steps: steps,
+                value: this.props.nullable
+                    ? undefined
+                    : {
+                        id: closestStep_1,
+                        label: this.secondsToLabel(closestStep_1, this.props.format),
+                    },
+            });
+            if (this.props.value || (!this.props.nullable && !this.props.value)) {
+                this.handleChange(closestStep_1);
+            }
+        }
+    };
+    TimePicker.prototype.componentDidUpdate = function (prevProps) {
+        var formatChanged = prevProps.format !== this.props.format;
+        var stepChanged = prevProps.step !== this.props.step;
+        var adapterChanged = prevProps.adapter !== this.props.adapter;
+        var minTimeChange = prevProps.minTime !== this.props.minTime;
+        var maxTimeChange = prevProps.maxTime !== this.props.maxTime;
+        if (adapterChanged) {
+            this.dateHelpers = new date_helpers_1.default(this.props.adapter);
+        }
+        if (formatChanged || stepChanged || minTimeChange || maxTimeChange) {
+            var steps = this.buildSteps();
+            this.setState({ steps: steps });
+        }
+        if (prevProps.value && !this.props.value) {
+            this.setState({ value: null });
+        }
+    };
+    TimePicker.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, format = _a.format, _b = _a.overrides, overrides = _b === void 0 ? {} : _b, adapter = _a.adapter;
+        var _c = (0, tslib_1.__read)((0, overrides_1.getOverrides)(overrides.Select, select_1.Select), 2), OverriddenSelect = _c[0], selectProps = _c[1];
+        selectProps.overrides = (0, overrides_1.mergeOverrides)({ Dropdown: { style: { maxHeight: '126px' } } }, selectProps.overrides);
+        var value = this.props.value && adapter.isValid(this.props.value)
+            ? this.buildSelectedOption(this.props.value, this.props.format)
+            : this.state.value;
+        return ((0, jsx_runtime_1.jsx)(locale_1.LocaleContext.Consumer, { children: function (locale) {
+                var ariaLabel = format === '12' ? locale.datepicker.timePickerAriaLabel12Hour : locale.datepicker.timePickerAriaLabel24Hour;
+                return ((0, jsx_runtime_1.jsx)(OverriddenSelect, (0, tslib_1.__assign)({ "aria-label": ariaLabel, disabled: _this.props.disabled, error: _this.props.error, positive: _this.props.positive, size: _this.props.size, placeholder: _this.props.placeholder || 'HH:mm', options: _this.state.steps.map(function (n) { return ({
+                        id: n,
+                        label: _this.secondsToLabel(n, _this.props.format),
+                    }); }), filterOptions: _this.props.creatable ? _this.creatableFilterOptions : undefined, onChange: _this.onChange, 
+                    // if value is defined, it should be an array type
+                    value: value ? [value] : value, clearable: false, backspaceRemoves: false, valueKey: "label" }, selectProps), void 0));
+            } }, void 0));
+    };
+    TimePicker.defaultProps = {
+        format: '12',
+        step: 900,
+        creatable: false,
+        adapter: date_fns_adapter_1.default,
+        ignoreMinMaxDateComponent: false,
+    };
+    return TimePicker;
+}(React.Component));
+exports.default = TimePicker;

package/baseui/timepicker/types.d.ts

@@ -0,0 +1,54 @@
+import type { Override } from '../helpers/overrides';
+import type { Option } from '../select';
+import type { Size } from '../input';
+import type { DateIOAdapter } from '../datepicker/utils/types';
+export declare type TimePickerOverrides = {
+    Select?: Override;
+};
+export declare type TimePickerProps<T = Date> = {
+    /** Render options in AM/PM format or 24 hour format. Defaults to 12 hour. */
+    adapter: DateIOAdapter<T>;
+    format?: '12' | '24';
+    /** Callback for when time selection changes. */
+    onChange?: (a: T | null) => unknown;
+    overrides?: TimePickerOverrides;
+    /** Set to true to allow times that aren't displayed in the options list to be entered manually. Defaults to false. */
+    creatable?: boolean;
+    /** Amount of seconds between each option time. Defaults to 900 (15 minutes). */
+    step?: number;
+    /**
+     * Optional value that can be provided to fully control the component. If not provided, TimePicker
+     * will manage state internally and default to the closest step to new Date().
+     */
+    value?: T | null;
+    disabled?: boolean;
+    error?: boolean;
+    positive?: boolean;
+    nullable?: boolean;
+    placeholder?: string;
+    size?: Size;
+    minTime?: T;
+    maxTime?: T;
+    /**
+     * There are two strategies available for setting min/max times. If the min/max datetimes are
+     * beyond the start/end times of the current value's date, Timepicker could either clamp the
+     * min/max time of the start/end of the day or it can ignore the min/max date components and
+     * only apply the time components. Each strategy has the potential to save developer time in
+     * avoiding the need to perform conversion before providing min/max datetimes to the component.
+     * By default the component will clamp the time window and setting this flag will ignore dates.
+     */
+    ignoreMinMaxDateComponent?: boolean;
+};
+export declare type TimePickerState = {
+    /** List of times (in seconds) displayed in the dropdown menu. */
+    steps: number[];
+    /** Internal value of the selected time as an integer since midnight (0) */
+    value: Option | undefined | null;
+};
+export declare type TimePickerDefaultProps = {
+    format: '12';
+    step: 900;
+    creatable: false;
+    adapter: DateIOAdapter<Date>;
+    ignoreMinMaxDateComponent: false;
+};

package/baseui/timepicker/types.js

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

package/baseui/tooltip/constants.d.ts

@@ -0,0 +1 @@
+export { ACCESSIBILITY_TYPE, PLACEMENT, TRIGGER_TYPE, STATE_CHANGE_TYPE } from '../popover';

package/baseui/tooltip/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_CHANGE_TYPE = exports.TRIGGER_TYPE = exports.PLACEMENT = exports.ACCESSIBILITY_TYPE = 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 popover_1 = require("../popover");
+Object.defineProperty(exports, "ACCESSIBILITY_TYPE", { enumerable: true, get: function () { return popover_1.ACCESSIBILITY_TYPE; } });
+Object.defineProperty(exports, "PLACEMENT", { enumerable: true, get: function () { return popover_1.PLACEMENT; } });
+Object.defineProperty(exports, "TRIGGER_TYPE", { enumerable: true, get: function () { return popover_1.TRIGGER_TYPE; } });
+Object.defineProperty(exports, "STATE_CHANGE_TYPE", { enumerable: true, get: function () { return popover_1.STATE_CHANGE_TYPE; } });

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

@@ -0,0 +1,3 @@
+import type { BaseTooltipProps } from './types';
+declare const baseDefaultProps: Partial<BaseTooltipProps>;
+export default baseDefaultProps;

package/baseui/tooltip/default-props.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+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 constants_1 = require("./constants");
+var baseDefaultProps = {
+    accessibilityType: constants_1.ACCESSIBILITY_TYPE.tooltip,
+    focusLock: false,
+    autoFocus: false,
+    returnFocus: false,
+    onMouseEnterDelay: 200,
+    onMouseLeaveDelay: 200,
+    overrides: {},
+    placement: constants_1.PLACEMENT.auto,
+    popoverMargin: 0,
+    showArrow: false,
+    triggerType: constants_1.TRIGGER_TYPE.hover,
+    renderAll: false,
+};
+exports.default = baseDefaultProps;

package/baseui/tooltip/index.d.ts

@@ -0,0 +1,6 @@
+export { default as StatefulTooltip } from './stateful-tooltip';
+export { default as StatefulContainer } from './stateful-tooltip-container';
+export { default as Tooltip } from './tooltip';
+export { ACCESSIBILITY_TYPE, PLACEMENT, TRIGGER_TYPE, STATE_CHANGE_TYPE } from './constants';
+export { Arrow as StyledArrow, Body as StyledBody, Inner as StyledInner, } from './styled-components';
+export * from './types';

package/baseui/tooltip/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyledInner = exports.StyledBody = exports.StyledArrow = exports.STATE_CHANGE_TYPE = exports.TRIGGER_TYPE = exports.PLACEMENT = exports.ACCESSIBILITY_TYPE = exports.Tooltip = exports.StatefulContainer = exports.StatefulTooltip = 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 stateful_tooltip_1 = require("./stateful-tooltip");
+Object.defineProperty(exports, "StatefulTooltip", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(stateful_tooltip_1).default; } });
+var stateful_tooltip_container_1 = require("./stateful-tooltip-container");
+Object.defineProperty(exports, "StatefulContainer", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(stateful_tooltip_container_1).default; } });
+var tooltip_1 = require("./tooltip");
+Object.defineProperty(exports, "Tooltip", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(tooltip_1).default; } });
+// Constants
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "ACCESSIBILITY_TYPE", { enumerable: true, get: function () { return constants_1.ACCESSIBILITY_TYPE; } });
+Object.defineProperty(exports, "PLACEMENT", { enumerable: true, get: function () { return constants_1.PLACEMENT; } });
+Object.defineProperty(exports, "TRIGGER_TYPE", { enumerable: true, get: function () { return constants_1.TRIGGER_TYPE; } });
+Object.defineProperty(exports, "STATE_CHANGE_TYPE", { enumerable: true, get: function () { return constants_1.STATE_CHANGE_TYPE; } });
+// Styled elements
+var styled_components_1 = require("./styled-components");
+Object.defineProperty(exports, "StyledArrow", { enumerable: true, get: function () { return styled_components_1.Arrow; } });
+Object.defineProperty(exports, "StyledBody", { enumerable: true, get: function () { return styled_components_1.Body; } });
+Object.defineProperty(exports, "StyledInner", { enumerable: true, get: function () { return styled_components_1.Inner; } });
+// Flow
+(0, tslib_1.__exportStar)(require("./types"), exports);

package/baseui/tooltip/stateful-tooltip-container.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { StatefulTooltipContainerProps } from './types';
+declare class StatefulContainer extends React.Component<StatefulTooltipContainerProps> {
+    static defaultProps: Partial<StatefulTooltipContainerProps>;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default StatefulContainer;

package/baseui/tooltip/stateful-tooltip-container.js

@@ -0,0 +1,25 @@
+"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 popover_1 = require("../popover");
+var default_props_1 = (0, tslib_1.__importDefault)(require("./default-props"));
+var StatefulContainer = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(StatefulContainer, _super);
+    function StatefulContainer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    StatefulContainer.prototype.render = function () {
+        return (0, jsx_runtime_1.jsx)(popover_1.StatefulContainer, (0, tslib_1.__assign)({}, this.props), void 0);
+    };
+    StatefulContainer.defaultProps = (0, tslib_1.__assign)({}, default_props_1.default);
+    return StatefulContainer;
+}(React.Component));
+exports.default = StatefulContainer;

package/baseui/tooltip/stateful-tooltip.d.ts

@@ -0,0 +1,6 @@
+import type { StatefulTooltipProps } from './types';
+declare function StatefulTooltip(props: StatefulTooltipProps): import("react/jsx-runtime").JSX.Element;
+declare namespace StatefulTooltip {
+    var defaultProps: Partial<import("../popover").StatefulPopoverContainerProps>;
+}
+export default StatefulTooltip;

package/baseui/tooltip/stateful-tooltip.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_tooltip_container_1 = (0, tslib_1.__importDefault)(require("./stateful-tooltip-container"));
+var tooltip_1 = (0, tslib_1.__importDefault)(require("./tooltip"));
+function StatefulTooltip(props) {
+    var children = props.children, restProps = (0, tslib_1.__rest)(props, ["children"]);
+    return ((0, jsx_runtime_1.jsx)(stateful_tooltip_container_1.default, (0, tslib_1.__assign)({}, restProps, { children: function (tooltipProps) { return (0, jsx_runtime_1.jsx)(tooltip_1.default, (0, tslib_1.__assign)({}, tooltipProps, { children: children }), void 0); } }), void 0));
+}
+StatefulTooltip.defaultProps = stateful_tooltip_container_1.default.defaultProps;
+exports.default = StatefulTooltip;

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

@@ -0,0 +1,14 @@
+/**
+ * We want to reuse the default Popover styles and add our overrides
+ * for Tooltip. Normally you could do something like
+ * withStyleDeep(StyledPopoverBody, {...}), however this break the
+ * ability to use $style properly–the style overrides passed in by
+ * the customer will override the base styles but not the styles
+ * specified here.
+ *
+ * We could create our own withStyleDeep that also takes the $style
+ * prop into account
+ */
+export declare const Body: import("../../style/styled").StyledComponent;
+export declare const Inner: import("../../style/styled").StyledComponent;
+export declare const Arrow: import("../../style/styled").StyledComponent;

package/baseui/tooltip/styled-components.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arrow = exports.Inner = exports.Body = 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 styled_components_1 = require("../popover/styled-components");
+var utils_1 = require("../popover/utils");
+/**
+ * We want to reuse the default Popover styles and add our overrides
+ * for Tooltip. Normally you could do something like
+ * withStyleDeep(StyledPopoverBody, {...}), however this break the
+ * ability to use $style properly–the style overrides passed in by
+ * the customer will override the base styles but not the styles
+ * specified here.
+ *
+ * We could create our own withStyleDeep that also takes the $style
+ * prop into account
+ */
+exports.Body = (0, style_1.styled)('div', 'rounded-8 spr-text-06', function (_, props) { return ((0, tslib_1.__assign)((0, tslib_1.__assign)({}, (0, styled_components_1.getBodyStyles)(_, props)), { 
+    // color: props.$theme.colors.tooltipText,
+    // Reset transition property to opacity only, and static transform
+    transitionProperty: 'opacity', transform: (0, utils_1.getEndPosition)(props.$popoverOffset) })); });
+exports.Body.displayName = 'Body';
+exports.Inner = (0, style_1.styled)('div', styled_components_1.getInnerStyles);
+exports.Inner.displayName = 'Inner';
+exports.Arrow = (0, style_1.styled)('div', styled_components_1.getArrowStyles);
+exports.Arrow.displayName = 'Arrow';

package/baseui/tooltip/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { TooltipProps } from './types';
+declare class Tooltip extends React.Component<TooltipProps> {
+    static defaultProps: Partial<TooltipProps>;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export default Tooltip;

package/baseui/tooltip/tooltip.js

@@ -0,0 +1,33 @@
+"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.
+*/
+/* eslint-disable react/no-find-dom-node */
+var React = (0, tslib_1.__importStar)(require("react"));
+var popover_1 = require("../popover");
+var overrides_1 = require("../helpers/overrides");
+var default_props_1 = (0, tslib_1.__importDefault)(require("./default-props"));
+var styled_components_1 = require("./styled-components");
+var Tooltip = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Tooltip, _super);
+    function Tooltip() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Tooltip.prototype.render = function () {
+        var overrides = (0, overrides_1.mergeOverrides)({
+            Arrow: styled_components_1.Arrow,
+            Body: styled_components_1.Body,
+            Inner: styled_components_1.Inner,
+        }, this.props.overrides);
+        return ((0, jsx_runtime_1.jsx)(popover_1.Popover, (0, tslib_1.__assign)({ autoFocus: false, "data-baseweb": "tooltip" }, this.props, { overrides: overrides }), void 0));
+    };
+    Tooltip.defaultProps = (0, tslib_1.__assign)({}, default_props_1.default);
+    return Tooltip;
+}(React.Component));
+exports.default = Tooltip;

package/baseui/tooltip/types.d.ts

@@ -0,0 +1,8 @@
+import type { AccessibilityType, BasePopoverProps, Child, Children, ContentRenderProp, PopoverOverrides, PopoverPlacement, PopoverProps, PopoverPropsWithoutChildren, StateChangeType, State, StatefulContentRenderProp, StatefulPopoverProps, StatefulPopoverContainerProps, StateReducer, TriggerType } from '../popover';
+declare type BaseTooltipProps = BasePopoverProps;
+declare type TooltipPlacement = PopoverPlacement;
+declare type TooltipProps = PopoverProps;
+declare type TooltipPropsWithoutChildren = PopoverPropsWithoutChildren;
+declare type StatefulTooltipProps = StatefulPopoverProps;
+declare type StatefulTooltipContainerProps = StatefulPopoverContainerProps;
+export type { AccessibilityType, BaseTooltipProps, Child, Children, ContentRenderProp, PopoverOverrides, TooltipProps, State, StateChangeType, StateReducer, StatefulContentRenderProp, StatefulTooltipProps, StatefulTooltipContainerProps, TooltipPlacement, TooltipPropsWithoutChildren, TriggerType, };

package/baseui/tooltip/types.js

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

package/baseui/tree-view/index.d.ts

@@ -0,0 +1,11 @@
+import type { TreeNodeData } from './types';
+import { toggleIsExpanded } from './utils';
+export { default as TreeView } from './tree-view';
+export { default as StatefulTreeView } from './stateful-tree-view';
+export * from './types';
+export { StyledTreeItemList, StyledTreeItem, StyledItemContent, StyledIconContainer, } from './styled-components';
+export { default as TreeLabel } from './tree-label';
+export { default as TreeLabelInteractable } from './tree-label-interactable';
+export { toggleIsExpanded };
+/** @deprecated use TreeNodeData instead. To be removed in future versions.*/
+export declare type TreeNode<T = any> = TreeNodeData<T>;

package/baseui/tree-view/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleIsExpanded = exports.TreeLabelInteractable = exports.TreeLabel = exports.StyledIconContainer = exports.StyledItemContent = exports.StyledTreeItem = exports.StyledTreeItemList = exports.StatefulTreeView = exports.TreeView = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "toggleIsExpanded", { enumerable: true, get: function () { return utils_1.toggleIsExpanded; } });
+var tree_view_1 = require("./tree-view");
+Object.defineProperty(exports, "TreeView", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(tree_view_1).default; } });
+var stateful_tree_view_1 = require("./stateful-tree-view");
+Object.defineProperty(exports, "StatefulTreeView", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(stateful_tree_view_1).default; } });
+(0, tslib_1.__exportStar)(require("./types"), exports);
+var styled_components_1 = require("./styled-components");
+Object.defineProperty(exports, "StyledTreeItemList", { enumerable: true, get: function () { return styled_components_1.StyledTreeItemList; } });
+Object.defineProperty(exports, "StyledTreeItem", { enumerable: true, get: function () { return styled_components_1.StyledTreeItem; } });
+Object.defineProperty(exports, "StyledItemContent", { enumerable: true, get: function () { return styled_components_1.StyledItemContent; } });
+Object.defineProperty(exports, "StyledIconContainer", { enumerable: true, get: function () { return styled_components_1.StyledIconContainer; } });
+var tree_label_1 = require("./tree-label");
+Object.defineProperty(exports, "TreeLabel", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(tree_label_1).default; } });
+var tree_label_interactable_1 = require("./tree-label-interactable");
+Object.defineProperty(exports, "TreeLabelInteractable", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(tree_label_interactable_1).default; } });

package/baseui/tree-view/stateful-container.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import type { StatefulContainerProps, TreeNodeData } from './types';
+declare type StateType = {
+    data: TreeNodeData[];
+};
+export default class StatefulContainer extends React.Component<StatefulContainerProps, StateType> {
+    constructor(props: StatefulContainerProps);
+    onToggle: (node: TreeNodeData) => void;
+    render(): React.ReactNode;
+}
+export {};