@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/esm/baseui/timepicker/timepicker.js

@@ -0,0 +1,258 @@
+import { __assign, __extends, __read } from "tslib";
+import { jsx as _jsx } from "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.
+*/
+import * as React from 'react';
+import { getOverrides, mergeOverrides } from '../helpers/overrides';
+import { LocaleContext } from '../locale';
+import { filterOptions, Select } from '../select';
+import DateHelpers from '../datepicker/utils/date-helpers';
+import dateFnsAdapter from '../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) {
+    __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 = __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 = __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 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 DateHelpers(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 DateHelpers(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 = __read(getOverrides(overrides.Select, Select), 2), OverriddenSelect = _c[0], selectProps = _c[1];
+        selectProps.overrides = 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 (_jsx(LocaleContext.Consumer, { children: function (locale) {
+                var ariaLabel = format === '12' ? locale.datepicker.timePickerAriaLabel12Hour : locale.datepicker.timePickerAriaLabel24Hour;
+                return (_jsx(OverriddenSelect, __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: dateFnsAdapter,
+        ignoreMinMaxDateComponent: false,
+    };
+    return TimePicker;
+}(React.Component));
+export default TimePicker;

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

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

package/esm/baseui/tooltip/constants.d.ts

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

package/esm/baseui/tooltip/constants.js

@@ -0,0 +1,7 @@
+/*
+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.
+*/
+export { ACCESSIBILITY_TYPE, PLACEMENT, TRIGGER_TYPE, STATE_CHANGE_TYPE } from '../popover';

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

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

package/esm/baseui/tooltip/default-props.js

@@ -0,0 +1,22 @@
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+import { ACCESSIBILITY_TYPE, PLACEMENT, TRIGGER_TYPE } from './constants';
+var baseDefaultProps = {
+    accessibilityType: ACCESSIBILITY_TYPE.tooltip,
+    focusLock: false,
+    autoFocus: false,
+    returnFocus: false,
+    onMouseEnterDelay: 200,
+    onMouseLeaveDelay: 200,
+    overrides: {},
+    placement: PLACEMENT.auto,
+    popoverMargin: 0,
+    showArrow: false,
+    triggerType: TRIGGER_TYPE.hover,
+    renderAll: false,
+};
+export default baseDefaultProps;

package/esm/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/esm/baseui/tooltip/index.js

@@ -0,0 +1,15 @@
+/*
+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.
+*/
+export { default as StatefulTooltip } from './stateful-tooltip';
+export { default as StatefulContainer } from './stateful-tooltip-container';
+export { default as Tooltip } from './tooltip';
+// Constants
+export { ACCESSIBILITY_TYPE, PLACEMENT, TRIGGER_TYPE, STATE_CHANGE_TYPE } from './constants';
+// Styled elements
+export { Arrow as StyledArrow, Body as StyledBody, Inner as StyledInner, } from './styled-components';
+// Flow
+export * from './types';

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

@@ -0,0 +1,23 @@
+import { __assign, __extends } from "tslib";
+import { jsx as _jsx } from "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.
+*/
+import * as React from 'react';
+import { StatefulContainer as StatefulPopoverContainer } from '../popover';
+import baseDefaultProps from './default-props';
+var StatefulContainer = /** @class */ (function (_super) {
+    __extends(StatefulContainer, _super);
+    function StatefulContainer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    StatefulContainer.prototype.render = function () {
+        return _jsx(StatefulPopoverContainer, __assign({}, this.props), void 0);
+    };
+    StatefulContainer.defaultProps = __assign({}, baseDefaultProps);
+    return StatefulContainer;
+}(React.Component));
+export default StatefulContainer;

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

@@ -0,0 +1,10 @@
+import { __assign, __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import StatefulContainer from './stateful-tooltip-container';
+import Tooltip from './tooltip';
+function StatefulTooltip(props) {
+    var children = props.children, restProps = __rest(props, ["children"]);
+    return (_jsx(StatefulContainer, __assign({}, restProps, { children: function (tooltipProps) { return _jsx(Tooltip, __assign({}, tooltipProps, { children: children }), void 0); } }), void 0));
+}
+StatefulTooltip.defaultProps = StatefulContainer.defaultProps;
+export default StatefulTooltip;

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

@@ -0,0 +1,30 @@
+import { __assign } from "tslib";
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+import { styled } from '../../style';
+import { getBodyStyles, getArrowStyles, getInnerStyles } from '../popover/styled-components';
+import { getEndPosition } from '../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
+ */
+export var Body = styled('div', 'rounded-8 spr-text-06', function (_, props) { return (__assign(__assign({}, getBodyStyles(_, props)), { 
+    // color: props.$theme.colors.tooltipText,
+    // Reset transition property to opacity only, and static transform
+    transitionProperty: 'opacity', transform: getEndPosition(props.$popoverOffset) })); });
+Body.displayName = 'Body';
+export var Inner = styled('div', getInnerStyles);
+Inner.displayName = 'Inner';
+export var Arrow = styled('div', getArrowStyles);
+Arrow.displayName = 'Arrow';

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

@@ -0,0 +1,31 @@
+import { __assign, __extends } from "tslib";
+import { jsx as _jsx } from "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 */
+import * as React from 'react';
+import { Popover } from '../popover';
+import { mergeOverrides } from '../helpers/overrides';
+import baseDefaultProps from './default-props';
+import { Arrow as StyledArrow, Body as StyledBody, Inner as StyledInner, } from './styled-components';
+var Tooltip = /** @class */ (function (_super) {
+    __extends(Tooltip, _super);
+    function Tooltip() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Tooltip.prototype.render = function () {
+        var overrides = mergeOverrides({
+            Arrow: StyledArrow,
+            Body: StyledBody,
+            Inner: StyledInner,
+        }, this.props.overrides);
+        return (_jsx(Popover, __assign({ autoFocus: false, "data-baseweb": "tooltip" }, this.props, { overrides: overrides }), void 0));
+    };
+    Tooltip.defaultProps = __assign({}, baseDefaultProps);
+    return Tooltip;
+}(React.Component));
+export default Tooltip;

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

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

package/esm/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/esm/baseui/tree-view/index.js

@@ -0,0 +1,8 @@
+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 };

package/esm/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 {};

package/esm/baseui/tree-view/stateful-container.js

@@ -0,0 +1,68 @@
+import { __assign, __extends, __rest, __values } from "tslib";
+/*
+Copyright (c) Uber Technologies, Inc.
+
+This source code is licensed under the MIT license found in the
+LICENSE file in the root directory of this source tree.
+*/
+import * as React from 'react';
+var findSiblings = function (node, children) {
+    var e_1, _a;
+    if (children.indexOf(node) !== -1) {
+        return children;
+    }
+    try {
+        for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+            var child = children_1_1.value;
+            if (child.children) {
+                var siblings = findSiblings(node, child.children);
+                if (siblings != null) {
+                    return siblings;
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return null;
+};
+var StatefulContainer = /** @class */ (function (_super) {
+    __extends(StatefulContainer, _super);
+    function StatefulContainer(props) {
+        var _this = _super.call(this, props) || this;
+        _this.onToggle = function (node) {
+            var _a = _this.props, onToggle = _a.onToggle, singleExpanded = _a.singleExpanded;
+            _this.setState(function (prevState) {
+                var shouldExpand = !node.isExpanded;
+                if (singleExpanded && shouldExpand) {
+                    var siblings = findSiblings(node, prevState.data);
+                    if (siblings != null) {
+                        siblings.forEach(function (sibling) {
+                            if (sibling !== node) {
+                                sibling.isExpanded = false;
+                            }
+                        });
+                    }
+                }
+                node.isExpanded = shouldExpand;
+                return { data: prevState.data };
+            }, function () {
+                onToggle && onToggle(node);
+            });
+        };
+        _this.state = { data: _this.props.data };
+        return _this;
+    }
+    StatefulContainer.prototype.render = function () {
+        var _a = this.props, children = _a.children, restProps = __rest(_a, ["children"]);
+        var onToggle = this.onToggle;
+        return children(Object.freeze(__assign(__assign(__assign({}, restProps), this.state), { onToggle: onToggle })));
+    };
+    return StatefulContainer;
+}(React.Component));
+export default StatefulContainer;

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

@@ -0,0 +1,2 @@
+import type { TreeViewProps } from './types';
+export default function StatefulTreeView(props: TreeViewProps): import("react/jsx-runtime").JSX.Element;

package/esm/baseui/tree-view/stateful-tree-view.js

@@ -0,0 +1,7 @@
+import { __assign } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import StatefulContainer from './stateful-container';
+import TreeView from './tree-view';
+export default function StatefulTreeView(props) {
+    return (_jsx(StatefulContainer, __assign({}, props, { children: function (treeViewProps) { return _jsx(TreeView, __assign({}, treeViewProps), void 0); } }), void 0));
+}