@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/esm/baseui/select/utils/index.js

@@ -0,0 +1,34 @@
+import { __assign } from "tslib";
+function groupedOptionsToArray(groupedOptions) {
+    return Object.keys(groupedOptions).reduce(function (arr, optgroup) {
+        var optgroupOptions = groupedOptions[optgroup];
+        return arr.concat(
+        // @ts-ignore
+        optgroupOptions.map(function (option) {
+            return __assign(__assign({}, option), { __optgroup: optgroup });
+        }));
+    }, []);
+}
+export function normalizeOptions(options) {
+    if (options) {
+        if (Array.isArray(options)) {
+            return options;
+        }
+        else {
+            return groupedOptionsToArray(options);
+        }
+    }
+    return [];
+}
+export var expandValue = function (value, props) {
+    if (!props.options)
+        return value;
+    var normalizedOptions = normalizeOptions(props.options);
+    for (var i = 0; i < normalizedOptions.length; i++) {
+        // @ts-ignore
+        if (String(normalizedOptions[i][props.valueKey]) === String(value[props.valueKey])) {
+            return normalizedOptions[i];
+        }
+    }
+    return value;
+};

package/esm/baseui/select/value.d.ts

@@ -0,0 +1 @@
+export default function Value(props: any): import("react/jsx-runtime").JSX.Element;

package/esm/baseui/select/value.js

@@ -0,0 +1,10 @@
+import { __assign, __read, __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { StyledSingleValue } from './styled-components';
+import { getOverrides } from '../helpers/overrides';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default function Value(props) {
+    var _a = props.overrides, overrides = _a === void 0 ? {} : _a, restProps = __rest(props, ["overrides"]);
+    var _b = __read(getOverrides(overrides.SingleValue, StyledSingleValue), 2), SingleValue = _b[0], singleValueProps = _b[1];
+    return (_jsx(SingleValue, __assign({}, restProps, singleValueProps, { children: props.children }), void 0));
+}

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

@@ -0,0 +1,4 @@
+export declare const STATE_CHANGE_TYPE: Readonly<{
+    readonly change: "change";
+    readonly finalChange: "finalChange";
+}>;

package/esm/baseui/slider/constants.js

@@ -0,0 +1,10 @@
+/*
+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 var STATE_CHANGE_TYPE = Object.freeze({
+    change: 'change',
+    finalChange: 'finalChange',
+});

package/esm/baseui/slider/index.d.ts

@@ -0,0 +1,8 @@
+import type { StyleProps } from './types';
+export { default as Slider } from './slider';
+export { default as StatefulSlider } from './stateful-slider';
+export { default as StatefulContainer } from './stateful-slider-container';
+export { Root as StyledRoot, Track as StyledTrack, InnerTrack as StyledInnerTrack, Thumb as StyledThumb, InnerThumb as StyledInnerThumb, Tick as StyledTick, TickBar as StyledTickBar, ThumbValue as StyledThumbValue, Mark as StyledMark, } from './styled-components';
+export * from './types';
+/** @deprecated use StyleProps instead. To be removed in future versions.*/
+export declare type SharedProps = StyleProps;

package/esm/baseui/slider/index.js

@@ -0,0 +1,6 @@
+export { default as Slider } from './slider';
+export { default as StatefulSlider } from './stateful-slider';
+export { default as StatefulContainer } from './stateful-slider-container';
+// Styled elements
+export { Root as StyledRoot, Track as StyledTrack, InnerTrack as StyledInnerTrack, Thumb as StyledThumb, InnerThumb as StyledInnerThumb, Tick as StyledTick, TickBar as StyledTickBar, ThumbValue as StyledThumbValue, Mark as StyledMark, } from './styled-components';
+export * from './types';

package/esm/baseui/slider/slider.d.ts

@@ -0,0 +1,3 @@
+import type { SliderProps } from './types';
+declare function Slider({ overrides, disabled, marks, onChange, onFinalChange, min, max, step, persistentThumb, valueToLabel, value: providedValue, }: SliderProps): import("react/jsx-runtime").JSX.Element;
+export default Slider;

package/esm/baseui/slider/slider.js

@@ -0,0 +1,98 @@
+import { __assign, __read } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } 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 { Range } from 'react-range';
+import { isFocusVisible as focusVisible, forkFocus, forkBlur } from '../utils/focusVisible';
+import { Root as StyledRoot, Track as StyledTrack, InnerTrack as StyledInnerTrack, Tick as StyledTick, TickBar as StyledTickBar, Thumb as StyledThumb, InnerThumb as StyledInnerThumb, ThumbValue as StyledThumbValue, Mark as StyledMark, } from './styled-components';
+import { getOverrides } from '../helpers/overrides';
+import { useStyle } from '../../style';
+// value.length should not be bigger than two
+// because our design doesn't support more than
+// two thumbs
+var limitValue = function (value) {
+    if (value.length > 2 || value.length === 0) {
+        throw new Error('the value prop represents positions of thumbs, so its length can be only one or two');
+    }
+    return value;
+};
+function Slider(_a) {
+    var _b = _a.overrides, overrides = _b === void 0 ? {} : _b, _c = _a.disabled, disabled = _c === void 0 ? false : _c, _d = _a.marks, marks = _d === void 0 ? false : _d, _e = _a.onChange, onChange = _e === void 0 ? function () { } : _e, _f = _a.onFinalChange, onFinalChange = _f === void 0 ? function () { } : _f, _g = _a.min, min = _g === void 0 ? 0 : _g, _h = _a.max, max = _h === void 0 ? 100 : _h, _j = _a.step, step = _j === void 0 ? 1 : _j, _k = _a.persistentThumb, persistentThumb = _k === void 0 ? false : _k, _l = _a.valueToLabel, valueToLabel = _l === void 0 ? function (label) { return label; } : _l, providedValue = _a.value;
+    var _m = __read(React.useState(false), 2), isHovered0 = _m[0], setIsHovered0 = _m[1];
+    var _o = __read(React.useState(false), 2), isHovered1 = _o[0], setIsHovered1 = _o[1];
+    var _p = __read(React.useState(false), 2), isFocusVisible = _p[0], setIsFocusVisible = _p[1];
+    var _q = __read(React.useState(-1), 2), focusedThumbIndex = _q[0], setFocusedThumbIndex = _q[1];
+    var isRTL = useStyle().isRTL;
+    var handleFocus = React.useCallback(function (event) {
+        if (focusVisible(event)) {
+            setIsFocusVisible(true);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var index = event.target.parentNode.firstChild === event.target ? 0 : 1;
+        setFocusedThumbIndex(index);
+    }, []);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var handleBlur = React.useCallback(function (event) {
+        if (isFocusVisible !== false) {
+            setIsFocusVisible(false);
+        }
+        setFocusedThumbIndex(-1);
+    }, [isFocusVisible]);
+    var value = limitValue(providedValue);
+    var sharedProps = {
+        $disabled: disabled,
+        $step: step,
+        $min: min,
+        $max: max,
+        $marks: marks,
+        $value: value,
+        $isFocusVisible: isFocusVisible,
+    };
+    var _r = __read(getOverrides(overrides.Root, StyledRoot), 2), Root = _r[0], rootProps = _r[1];
+    var _s = __read(getOverrides(overrides.Track, StyledTrack), 2), Track = _s[0], trackProps = _s[1];
+    var _t = __read(getOverrides(overrides.InnerTrack, StyledInnerTrack), 2), InnerTrack = _t[0], innerTrackProps = _t[1];
+    var _u = __read(getOverrides(overrides.Thumb, StyledThumb), 2), Thumb = _u[0], thumbProps = _u[1];
+    var _v = __read(getOverrides(overrides.InnerThumb, StyledInnerThumb), 2), InnerThumb = _v[0], innerThumbProps = _v[1];
+    var _w = __read(getOverrides(overrides.ThumbValue, StyledThumbValue), 2), ThumbValue = _w[0], thumbValueProps = _w[1];
+    var _x = __read(getOverrides(overrides.Tick, StyledTick), 2), Tick = _x[0], tickProps = _x[1];
+    var _y = __read(getOverrides(overrides.TickBar, StyledTickBar), 2), TickBar = _y[0], tickBarProps = _y[1];
+    var _z = __read(getOverrides(overrides.Mark, StyledMark), 2), Mark = _z[0], markProps = _z[1];
+    return (_jsxs(Root, __assign({ "data-baseweb": "slider" }, sharedProps, rootProps, { onFocus: forkFocus(rootProps, handleFocus), onBlur: forkBlur(rootProps, handleBlur) }, { children: [_jsx(Range, __assign({ step: step, min: min, max: max, values: value, disabled: disabled, onChange: function (value) { return onChange({ value: value }); }, onFinalChange: function (value) { return onFinalChange({ value: value }); }, rtl: isRTL, renderTrack: function (_a) {
+                    var props = _a.props, children = _a.children, isDragged = _a.isDragged;
+                    return (_jsx(Track, __assign({ onMouseDown: props.onMouseDown, onTouchStart: props.onTouchStart, "$isDragged": isDragged }, sharedProps, trackProps, { children: _jsx(InnerTrack, __assign({ "$isDragged": isDragged, ref: props.ref }, sharedProps, innerTrackProps, { children: children }), void 0) }), void 0));
+                }, renderThumb: function (_a) {
+                    var props = _a.props, index = _a.index, isDragged = _a.isDragged;
+                    var displayLabel = persistentThumb
+                        ? persistentThumb
+                        : ((!!index && isHovered1) || (!index && isHovered0) || isDragged) && !disabled;
+                    return (_jsxs(Thumb, __assign({}, props, { onMouseEnter: function () {
+                            if (index === 0) {
+                                setIsHovered0(true);
+                            }
+                            else {
+                                setIsHovered1(true);
+                            }
+                        }, onMouseLeave: function () {
+                            if (index === 0) {
+                                setIsHovered0(false);
+                            }
+                            else {
+                                setIsHovered1(false);
+                            }
+                        }, "$thumbIndex": index, "$isDragged": isDragged, style: __assign(__assign({}, props.style), { zIndex: 'unset' }) }, sharedProps, thumbProps, { "$isFocusVisible": isFocusVisible && focusedThumbIndex === index }, { children: [displayLabel && (_jsx(ThumbValue, __assign({ "$thumbIndex": index, "$isDragged": isDragged }, sharedProps, thumbValueProps, { children: valueToLabel(value[index]) }), void 0)), displayLabel && (_jsx(InnerThumb, __assign({ "$thumbIndex": index, "$isDragged": isDragged }, sharedProps, innerThumbProps), void 0))] }), void 0));
+                } }, (marks
+                ? {
+                    // eslint-disable-next-line react/display-name
+                    renderMark: function (_a) {
+                        var props = _a.props, index = _a.index;
+                        return _jsx(Mark, __assign({ "$markIndex": index }, props, sharedProps, markProps), void 0);
+                    },
+                }
+                : {})), void 0), _jsxs(TickBar, __assign({}, sharedProps, tickBarProps, { children: [_jsx(Tick, __assign({}, sharedProps, tickProps, { children: valueToLabel(min) }), void 0), _jsx(Tick, __assign({}, sharedProps, tickProps, { children: valueToLabel(max) }), void 0)] }), void 0)] }), void 0));
+}
+export default Slider;

package/esm/baseui/slider/stateful-slider-container.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import type { StatefulContainerProps, StateReducer, State, Params, ChangeAction } from './types';
+declare class StatefulSliderContainer extends React.Component<StatefulContainerProps, State> {
+    static defaultProps: {
+        stateReducer: StateReducer;
+        min: number;
+        max: number;
+        step: number;
+        marks: boolean;
+        onChange: () => void;
+        onFinalChange: () => void;
+    };
+    constructor(props: StatefulContainerProps);
+    onChange: (params: {
+        value: Array<number>;
+    }) => unknown;
+    onFinalChange: (params: {
+        value: Array<number>;
+    }) => unknown;
+    internalSetState: (type: ChangeAction, { value }: Params) => void;
+    render(): React.ReactNode;
+}
+export default StatefulSliderContainer;

package/esm/baseui/slider/stateful-slider-container.js

@@ -0,0 +1,57 @@
+import { __assign, __extends, __rest } 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';
+import { STATE_CHANGE_TYPE } from './constants';
+var defaultStateReducer = function (type, nextState) { return nextState; };
+var StatefulSliderContainer = /** @class */ (function (_super) {
+    __extends(StatefulSliderContainer, _super);
+    function StatefulSliderContainer(props) {
+        var _this = _super.call(this, props) || this;
+        _this.onChange = function (params) {
+            _this.internalSetState(STATE_CHANGE_TYPE.change, params);
+            return _this.props.onChange(__assign({}, params));
+        };
+        _this.onFinalChange = function (params) {
+            _this.internalSetState(STATE_CHANGE_TYPE.finalChange, params);
+            return _this.props.onFinalChange(__assign({}, params));
+        };
+        _this.internalSetState = function (type, _a) {
+            var value = _a.value;
+            var nextState = { value: value };
+            var stateReducer = _this.props.stateReducer;
+            var newState = stateReducer(type, nextState, _this.state);
+            _this.setState(newState);
+        };
+        _this.state = {
+            value: props.initialState && Array.isArray(props.initialState.value)
+                ? props.initialState.value
+                : [Math.round((props.max - props.min) / 2) + props.min],
+        };
+        return _this;
+    }
+    StatefulSliderContainer.prototype.render = function () {
+        var _a = this.props, children = _a.children, 
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        initialState = _a.initialState, // eslint-disable-line no-unused-vars
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        stateReducer = _a.stateReducer, // eslint-disable-line no-unused-vars
+        restProps = __rest(_a, ["children", "initialState", "stateReducer"]);
+        return children(__assign(__assign(__assign({}, restProps), this.state), { onChange: this.onChange, onFinalChange: this.onFinalChange }));
+    };
+    StatefulSliderContainer.defaultProps = {
+        stateReducer: defaultStateReducer,
+        min: 0,
+        max: 100,
+        step: 1,
+        marks: false,
+        onChange: function () { },
+        onFinalChange: function () { },
+    };
+    return StatefulSliderContainer;
+}(React.Component));
+export default StatefulSliderContainer;

package/esm/baseui/slider/stateful-slider.d.ts

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

package/esm/baseui/slider/stateful-slider.js

@@ -0,0 +1,7 @@
+import { __assign } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import StatefulSliderContainer from './stateful-slider-container';
+import Slider from './slider';
+export default function StatefulSlider(props) {
+    return (_jsx(StatefulSliderContainer, __assign({}, props, { children: function (childrenProps) { return _jsx(Slider, __assign({}, childrenProps), void 0); } }), void 0));
+}

package/esm/baseui/slider/styled-components.d.ts

@@ -0,0 +1,9 @@
+export declare const Root: import("../../style/styled").StyledComponent;
+export declare const Track: import("../../style/styled").StyledComponent;
+export declare const InnerTrack: import("../../style/styled").StyledComponent;
+export declare const Mark: import("../../style/styled").StyledComponent;
+export declare const Tick: import("../../style/styled").StyledComponent;
+export declare const TickBar: import("../../style/styled").StyledComponent;
+export declare const Thumb: import("../../style/styled").StyledComponent;
+export declare const InnerThumb: import("../../style/styled").StyledComponent;
+export declare const ThumbValue: import("../../style/styled").StyledComponent;

package/esm/baseui/slider/styled-components.js

@@ -0,0 +1,55 @@
+/*
+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';
+export var Root = styled('div', { position: 'relative', width: '100%' });
+Root.displayName = 'Root';
+Root.displayName = 'StyledRoot';
+export var Track = styled('div', 'flex bg-transparent', function (_, props) {
+    var _a = props.$value, $value = _a === void 0 ? [] : _a, $disabled = props.$disabled, $isDragged = props.$isDragged;
+    var cursor = 'inherit';
+    if ($disabled) {
+        cursor = 'not-allowed';
+    }
+    else if ($isDragged) {
+        cursor = 'grabbing';
+    }
+    else if ($value.length === 1) {
+        cursor = 'pointer';
+    }
+    return {
+        cursor: cursor,
+    };
+});
+Track.displayName = 'Track';
+Track.displayName = 'StyledTrack';
+export var InnerTrack = styled('div');
+InnerTrack.displayName = 'InnerTrack';
+InnerTrack.displayName = 'StyledInnerTrack';
+export var Mark = styled('div');
+Mark.displayName = 'Mark';
+Mark.displayName = 'StyledMark';
+export var Tick = styled('div');
+Tick.displayName = 'Tick';
+Tick.displayName = 'StyledTick';
+export var TickBar = styled('div');
+TickBar.displayName = 'TickBar';
+TickBar.displayName = 'StyledTickBar';
+export var Thumb = styled('div', function (_a, _b) {
+    var theme = _a.theme;
+    var $isFocusVisible = _b.$isFocusVisible;
+    return ({
+        boxShadow: $isFocusVisible ? "0 0 0 3px ".concat(theme.spr.focus01) : '0 1px 4px rgba(0, 0, 0, 0.12)',
+    });
+});
+Thumb.displayName = 'Thumb';
+Thumb.displayName = 'StyledThumb';
+export var InnerThumb = styled('div');
+InnerThumb.displayName = 'InnerThumb';
+InnerThumb.displayName = 'StyledInnerThumb';
+export var ThumbValue = styled('div', 'whitespace-no-wrap');
+ThumbValue.displayName = 'ThumbValue';
+ThumbValue.displayName = 'StyledThumbValue';

package/esm/baseui/slider/types.d.ts

@@ -0,0 +1,74 @@
+import type { Override } from '../helpers/overrides';
+import type { STATE_CHANGE_TYPE } from './constants';
+import type { ReactNode } from 'react';
+export declare type ChangeAction = keyof typeof STATE_CHANGE_TYPE;
+export declare type Params = {
+    value: Array<number>;
+};
+export declare type SliderOverrides = {
+    Root?: Override;
+    Track?: Override;
+    InnerTrack?: Override;
+    Tick?: Override;
+    TickBar?: Override;
+    Thumb?: Override;
+    InnerThumb?: Override;
+    ThumbValue?: Override;
+    Mark?: Override;
+};
+export declare type SliderProps = {
+    /** Position of the thumbs. It can be a single point (one thumb) or 2 points array (range thumbs). */
+    value: Array<number>;
+    /** The minimum allowed value of the slider. Should not be bigger than max. */
+    min?: number;
+    /** The maximum allowed value of the slider. Should not be smaller than min. */
+    max?: number;
+    /** The granularity the slider can step through value. Default step is 1. */
+    step?: number;
+    overrides?: SliderOverrides;
+    /** Disable control from being changed. */
+    disabled?: boolean;
+    /** Display a mark at each step. */
+    marks?: boolean;
+    /** Always display the selected value/thumb/label. */
+    persistentThumb?: boolean;
+    /** Function to change the numeric value to a user friendly value. Also applied to min/max labels. */
+    valueToLabel?: (value: number) => ReactNode;
+    /** Handler for events on trigger element, each time thumbs change selection, which is passed in `value`. */
+    onChange?: (a: Params) => unknown;
+    /** Handler for events on trigger element, each time thumbs finish changing selection, which is passed in `value`. */
+    onFinalChange?: (a: Params) => unknown;
+};
+export declare type State = {
+    value: Array<number>;
+};
+export declare type StateReducer = (stateType: string, nextState: State, currentState: State) => State;
+export declare type StatefulContainerProps = {
+    overrides?: SliderOverrides;
+    children: (a: SliderProps) => ReactNode;
+    min: number;
+    max: number;
+    step: number;
+    /** Initial state populated into the component */
+    initialState?: State;
+    /** Reducer function to manipulate internal state updates. */
+    stateReducer: StateReducer;
+    /** Handler for events on trigger element, each time thumbs change selection, which is passed in `value`. */
+    onChange: (a: {} & Params) => unknown;
+    /** Handler for events on trigger element, each time thumbs finish changing selection, which is passed in `value`. */
+    onFinalChange: (a: {} & Params) => unknown;
+};
+export declare type StatefulSliderProps = {
+    /** Initial state populated into the component */
+    initialState?: State;
+} & Omit<SliderProps, 'value'>;
+export declare type StyleProps = {
+    $disabled?: boolean;
+    $isDragged?: boolean;
+    $marks?: boolean;
+    $max?: number;
+    $min?: number;
+    $thumbIndex?: number;
+    $value?: Array<number>;
+    $isFocusVisible?: boolean;
+};

package/esm/baseui/slider/types.js

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

package/esm/baseui/table-semantic/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const DIVIDER: Readonly<{
+    readonly horizontal: "horizontal";
+    readonly vertical: "vertical";
+    readonly grid: "grid";
+    readonly clean: "clean";
+}>;
+export declare const SIZE: Readonly<{
+    readonly compact: "compact";
+    readonly default: "default";
+    readonly spacious: "spacious";
+}>;

package/esm/baseui/table-semantic/constants.js

@@ -0,0 +1,17 @@
+/*
+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 var DIVIDER = Object.freeze({
+    horizontal: 'horizontal',
+    vertical: 'vertical',
+    grid: 'grid',
+    clean: 'clean',
+});
+export var SIZE = Object.freeze({
+    compact: 'compact',
+    default: 'default',
+    spacious: 'spacious',
+});

package/esm/baseui/table-semantic/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Table } from './table';
+export { DIVIDER, SIZE } from './constants';
+export { StyledRoot, StyledTable, StyledTableHead, StyledTableHeadRow, StyledTableHeadCell, StyledTableBody, StyledTableBodyRow, StyledTableBodyCell, StyledTableLoadingMessage, StyledTableEmptyMessage, } from './styled-components';
+export * from './types';

package/esm/baseui/table-semantic/index.js

@@ -0,0 +1,12 @@
+/*
+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 Table } from './table';
+export { DIVIDER, SIZE } from './constants';
+// Styled elements
+export { StyledRoot, StyledTable, StyledTableHead, StyledTableHeadRow, StyledTableHeadCell, StyledTableBody, StyledTableBodyRow, StyledTableBodyCell, StyledTableLoadingMessage, StyledTableEmptyMessage, } from './styled-components';
+// Flow
+export * from './types';

package/esm/baseui/table-semantic/styled-components.d.ts

@@ -0,0 +1,11 @@
+export declare const StyledRoot: import("../../style/styled").StyledComponent;
+export declare const StyledTable: import("../../style/styled").StyledComponent;
+export declare const StyledTableHead: import("../../style/styled").StyledComponent;
+export declare const StyledTableHeadRow: import("../../style/styled").StyledComponent;
+export declare const StyledTableHeadCell: import("../../style/styled").StyledComponent;
+export declare const StyledSortIconContainer: import("../../style/styled").StyledComponent;
+export declare const StyledTableBody: import("../../style/styled").StyledComponent;
+export declare const StyledTableBodyRow: import("../../style/styled").StyledComponent;
+export declare const StyledTableBodyCell: import("../../style/styled").StyledComponent;
+export declare const StyledTableLoadingMessage: import("../../style/styled").StyledComponent;
+export declare const StyledTableEmptyMessage: import("../../style/styled").StyledComponent;

package/esm/baseui/table-semantic/styled-components.js

@@ -0,0 +1,39 @@
+/*
+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';
+export var StyledRoot = styled('div', 'overflow-auto relative spr-ui-01', {
+    WebkitOverflowScrolling: 'touch',
+    transform: 'scale(1)',
+});
+StyledRoot.displayName = 'StyledRoot';
+export var StyledTable = styled('table', 'min-w-full box-border border-0 border-none', function (_, _a) {
+    var $width = _a.$width;
+    return ({
+        borderSpacing: '0',
+        width: $width || null,
+    });
+});
+StyledTable.displayName = 'StyledTable';
+export var StyledTableHead = styled('thead');
+StyledTableHead.displayName = 'StyledTableHead';
+export var StyledTableHeadRow = styled('tr');
+StyledTableHeadRow.displayName = 'StyledTableHeadRow';
+export var StyledTableHeadCell = styled('th', 'text-16 leading-8 text-left p-4 sticky font-500 border-b spr-border-03 whitespace-no-wrap', { top: 0, zIndex: 1, borderBottomStyle: 'solid' });
+StyledTableHeadCell.displayName = 'StyledTableHeadCell';
+export var StyledSortIconContainer = styled('span');
+StyledSortIconContainer.displayName = 'StyledSortIconContainer';
+export var StyledTableBody = styled('tbody');
+StyledTableBody.displayName = 'StyledTableBody';
+export var StyledTableBodyRow = styled('tr', 'hover:spr-tag ');
+StyledTableBodyRow.displayName = 'StyledTableBodyRow';
+export var StyledTableBodyCell = styled('td', 'p-4 border-b spr-border-03 leading-8 text-14 align-top', {
+    borderBottomStyle: 'solid',
+});
+StyledTableBodyCell.displayName = 'StyledTableBodyCell';
+export var StyledTableLoadingMessage = styled('div');
+StyledTableLoadingMessage.displayName = 'StyledTableLoadingMessage';
+export var StyledTableEmptyMessage = StyledTableLoadingMessage;

package/esm/baseui/table-semantic/table-builder-column.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { TableBuilderColumnProps } from './types';
+export default class TableBuilderColumn<T> extends React.Component<TableBuilderColumnProps<T>> {
+}

package/esm/baseui/table-semantic/table-builder-column.js

@@ -0,0 +1,16 @@
+import { __extends } 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 TableBuilderColumn = /** @class */ (function (_super) {
+    __extends(TableBuilderColumn, _super);
+    function TableBuilderColumn() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return TableBuilderColumn;
+}(React.Component));
+export default TableBuilderColumn;

package/esm/baseui/table-semantic/table-builder.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import type { TableBuilderProps } from './types';
+import type { SyntheticEvent } from 'react';
+export default class TableBuilder<T> extends React.Component<TableBuilderProps<T>, {
+    isFocusVisible: boolean;
+}> {
+    static defaultProps: {
+        data: never[];
+        loadingMessage: string;
+    };
+    state: {
+        isFocusVisible: boolean;
+    };
+    handleFocus: (event: SyntheticEvent) => void;
+    handleBlur: (event: SyntheticEvent) => void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}