@sprinklrjs/spaceweb 12.14.4 → 12.33.2

package/esm/baseui/utils/focusVisible.js

@@ -0,0 +1,160 @@
+/*
+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 { isServer } from '../../spacewebProvider/utils';
+// based on:
+// - https://github.com/mui-org/material-ui/blob/master/packages/material-ui/src/utils/focusVisible.js
+// - https://github.com/WICG/focus-visible/blob/v4.1.5/src/focus-visible.js
+var initialized = false;
+var hadKeyboardEvent = true;
+var hadFocusVisibleRecently = false;
+// @ts-ignore
+var hadFocusVisibleRecentlyTimeout = null;
+var inputTypesWhitelist = {
+    text: true,
+    search: true,
+    url: true,
+    tel: true,
+    email: true,
+    password: true,
+    number: true,
+    date: true,
+    month: true,
+    week: true,
+    time: true,
+    datetime: true,
+    'datetime-local': true,
+};
+/**
+ * Computes whether the given element should automatically trigger the
+ * `focus-visible` class being added, i.e. whether it should always match
+ * `:focus-visible` when focused.
+ * @param {Element} node
+ * @return {boolean}
+ */
+// @ts-ignore
+function focusTriggersKeyboardModality(node) {
+    var type = node.type, tagName = node.tagName;
+    // @ts-ignore
+    if (tagName === 'INPUT' && inputTypesWhitelist[type] && !node.readOnly) {
+        return true;
+    }
+    if (tagName === 'TEXTAREA' && !node.readOnly) {
+        return true;
+    }
+    if (node.isContentEditable) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Keep track of our keyboard modality state with `hadKeyboardEvent`.
+ * If the most recent user interaction was via the keyboard;
+ * and the key press did not include a meta, alt/option, or control key;
+ * then the modality is keyboard. Otherwise, the modality is not keyboard.
+ * @param {KeyboardEvent} event
+ */
+// @ts-ignore
+function handleKeyDown(event) {
+    if (event.metaKey || event.altKey || event.ctrlKey) {
+        return;
+    }
+    hadKeyboardEvent = true;
+}
+/**
+ * If at any point a user clicks with a pointing device, ensure that we change
+ * the modality away from keyboard.
+ * This avoids the situation where a user presses a key on an already focused
+ * element, and then clicks on a different element, focusing it with a
+ * pointing device, while we still think we're in keyboard modality.
+ */
+function handlePointerDown() {
+    hadKeyboardEvent = false;
+}
+function handleVisibilityChange() {
+    // @ts-ignore
+    if (this.visibilityState === 'hidden') {
+        // If the tab becomes active again, the browser will handle calling focus
+        // on the element (Safari actually calls it twice).
+        // If this tab change caused a blur on an element with focus-visible,
+        // re-apply the class when the user switches back to the tab.
+        if (hadFocusVisibleRecently) {
+            hadKeyboardEvent = true;
+        }
+    }
+}
+// @ts-ignore
+function prepare(doc) {
+    doc.addEventListener('keydown', handleKeyDown, true);
+    doc.addEventListener('mousedown', handlePointerDown, true);
+    doc.addEventListener('pointerdown', handlePointerDown, true);
+    doc.addEventListener('touchstart', handlePointerDown, true);
+    doc.addEventListener('visibilitychange', handleVisibilityChange, true);
+}
+// @ts-ignore
+export function teardown(doc) {
+    doc.removeEventListener('keydown', handleKeyDown, true);
+    doc.removeEventListener('mousedown', handlePointerDown, true);
+    doc.removeEventListener('pointerdown', handlePointerDown, true);
+    doc.removeEventListener('touchstart', handlePointerDown, true);
+    doc.removeEventListener('visibilitychange', handleVisibilityChange, true);
+}
+// @ts-ignore
+export function isFocusVisible(event) {
+    try {
+        return event.target.matches(':focus-visible');
+    }
+    catch (error) {
+        // browsers not implementing :focus-visible will throw a SyntaxError
+        // we use our own heuristic for those browsers
+        // rethrow might be better if it's not the expected error but do we really
+        // want to crash if focus-visible malfunctioned?
+    }
+    // no need for validFocusTarget check. the user does that by attaching it to
+    // focusable events only
+    return hadKeyboardEvent || focusTriggersKeyboardModality(event.target);
+}
+/**
+ * Should be called if a blur event is fired on a focus-visible element
+ */
+export function handleBlurVisible() {
+    // To detect a tab/window switch, we look for a blur event followed
+    // rapidly by a visibility change.
+    // If we don't see a visibility change within 100ms, it's probably a
+    // regular focus change.
+    hadFocusVisibleRecently = true;
+    if (!isServer) {
+        // @ts-ignore
+        window.clearTimeout(hadFocusVisibleRecentlyTimeout);
+        // @ts-ignore
+        hadFocusVisibleRecentlyTimeout = window.setTimeout(function () {
+            hadFocusVisibleRecently = false;
+        }, 100);
+    }
+}
+// @ts-ignore
+export function initFocusVisible(node) {
+    if (!initialized && node != null) {
+        initialized = true;
+        prepare(node.ownerDocument);
+    }
+}
+export var forkFocus = 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function (rootProps, handler) { return function (e) {
+    if (typeof rootProps.onFocus === 'function') {
+        rootProps.onFocus(e);
+    }
+    handler(e);
+}; };
+export var forkBlur = 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function (rootProps, handler) { return function (e) {
+    if (typeof rootProps.onBlur === 'function') {
+        rootProps.onBlur(e);
+    }
+    handler(e);
+}; };

package/esm/baseui/utils/react-18.d.ts

@@ -0,0 +1 @@
+export declare const startTransition: (cb: () => void) => void;

package/esm/baseui/utils/react-18.js

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export var startTransition = function (cb) {
+    if (React.startTransition) {
+        React.startTransition(cb);
+    }
+    else {
+        cb();
+    }
+};

package/esm/breadcrumb/breadcrumb-item.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="react" />
 import { BreadcrumbItemProps } from './types';
 declare const BreadcrumbItem: {
-    ({ children, isLastChild, overrides, onClick, index, startEnhancer, endEnhancer, separator, gap, ...restProps }: BreadcrumbItemProps): JSX.Element;
+    ({ children, isLastChild, overrides, onClick, index, startEnhancer, endEnhancer, separator, gap, ...restProps }: BreadcrumbItemProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 export default BreadcrumbItem;

package/esm/breadcrumb/breadcrumb.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="react" />
 import { BreadcrumbProps } from './types';
 declare const Breadcrumb: {
-    ({ children, separator, gap, overrides, }: BreadcrumbProps): JSX.Element;
+    ({ children, separator, gap, overrides, }: BreadcrumbProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 export default Breadcrumb;

package/esm/breadcrumb/styled-components.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="react" />
 export declare const StyledStartEnhancer: import("../style/styled").StyledComponent;
 export declare const StyledEndEnhancer: import("../style/styled").StyledComponent;
 export declare const StyledWrapper: import("../style/styled").StyledComponent;
 export declare const StyledSeparator: import("../style/styled").StyledComponent;
 export declare const StyledListItem: import("../style/styled").StyledComponent;
-export declare const DEFAULT_SEPARATOR: JSX.Element;
+export declare const DEFAULT_SEPARATOR: import("react/jsx-runtime").JSX.Element;

package/esm/button/Button.d.ts

@@ -9,6 +9,7 @@ declare const Button: React.ForwardRefExoticComponent<Omit<{
     intent?: import("..").Intent | undefined;
     isLoading?: boolean | undefined;
     isSelected?: boolean | undefined;
+    animate?: boolean | undefined;
     disabled?: boolean | undefined;
     fullWidth?: boolean | undefined;
     autoFocus?: boolean | undefined;
@@ -17,12 +18,12 @@ declare const Button: React.ForwardRefExoticComponent<Omit<{
     target?: string | undefined;
     rel?: string | undefined;
     children?: React.ReactNode;
-    endEnhancer?: React.ReactNode;
+    endEnhancer?: React.ReactNode | React.ComponentType<any>;
     onClick?: ((event: React.MouseEvent<HTMLElement, MouseEvent>) => any) | undefined;
     overrides?: import("./types").ButtonOverrides | undefined;
-    startEnhancer?: React.ReactNode;
+    startEnhancer?: React.ReactNode | React.ComponentType<any>;
     type?: "button" | "reset" | "submit" | undefined;
-    tooltipContent?: React.ReactNode | import("baseui/popover").StatefulContentRenderProp;
+    tooltipContent?: React.ReactNode | import("../baseui/popover").ContentRenderProp;
     tabIndex?: number | undefined;
 }, "style" | "className"> & {
     $as?: React.ElementType<any> | undefined;

package/esm/button/Button.js

@@ -3,10 +3,9 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import * as React from 'react';
 import _pick from 'lodash/pick';
 import _omit from 'lodash/omit';
-import { Button as BaseUIButton } from 'baseui/button';
-import { useConvertOverrides } from '../helpers/baseui/useConvertOverrides';
+import { Button as BaseUIButton } from '../baseui/button';
 import { mergeOverrides, useOverrides } from '../overrides';
-import { getButtonStyles, StyledLoadingSpinnerContainer } from './styled-components';
+import { getButtonStyles, StyledLoadingSpinnerContainer, getLoaderMajorColor, getLoaderMinorColor, } from './styled-components';
 import adaptBaseButtonProps from './basewebAdapter';
 import { add$props } from '../helpers';
 import { StyledBaseButton as BaseButton } from '../base-button';
@@ -14,18 +13,20 @@ import { StatefulTooltip as DefaultStatefulTooltip, DisabledTooltipContainer } f
 import { useContextualFormProps } from '../form-control/context';
 import useStyle from '../style/useStyle';
 import { getDefaultSize } from '../helpers/themeHelpers';
+import { StyledClipLoader } from '../loader/styled-component';
 BaseUIButton.displayName = 'BaseUIButton';
 var Button = React.forwardRef(function (props, ref) {
     var buttonRef = ref;
-    var _a = useContextualFormProps(props), _b = _a.variant, variant = _b === void 0 ? 'primary' : _b, _c = _a.intent, intent = _c === void 0 ? 'default' : _c, _size = _a.size, fullWidth = _a.fullWidth, className = _a.className, style = _a.style, overrides = _a.overrides, tooltipContent = _a.tooltipContent, restProps = __rest(_a, ["variant", "intent", "size", "fullWidth", "className", "style", "overrides", "tooltipContent"]);
+    var _a = useContextualFormProps(props), _b = _a.variant, variant = _b === void 0 ? 'primary' : _b, _c = _a.intent, intent = _c === void 0 ? 'default' : _c, _size = _a.size, fullWidth = _a.fullWidth, className = _a.className, style = _a.style, overrides = _a.overrides, tooltipContent = _a.tooltipContent, animate = _a.animate, restProps = __rest(_a, ["variant", "intent", "size", "fullWidth", "className", "style", "overrides", "tooltipContent", "animate"]);
+    var isSelected = restProps.isSelected;
     var _d = useStyle(), getStyle = _d.getStyle, isRTL = _d.isRTL, theme = _d.theme;
     var size = _size !== null && _size !== void 0 ? _size : getDefaultSize(theme);
     var buttonOverrides = React.useMemo(function () { return _omit(overrides, 'StatefulTooltip'); }, [overrides]);
     var adaptedProps = adaptBaseButtonProps(__assign(__assign({}, restProps), { variant: variant, overrides: buttonOverrides }));
-    var convertedOverrides = useConvertOverrides(adaptedProps.overrides || {});
+    var convertedOverrides = mergeOverrides(adaptedProps.overrides || {});
     var mergedOverrides = mergeOverrides({
         BaseButton: {
-            props: __assign({ className: [getButtonStyles, className, style] }, add$props({ variant: variant, intent: intent, size: size, fullWidth: fullWidth })),
+            props: __assign({ className: [getButtonStyles, className, style] }, add$props({ variant: variant, intent: intent, size: size, fullWidth: fullWidth, animate: animate })),
             component: BaseButton, //using StyledBaseButton instead of BaseButton as all the handling is done by baseui's Button.
         },
         LoadingSpinnerContainer: {
@@ -35,26 +36,35 @@ var Button = React.forwardRef(function (props, ref) {
             },
         },
         LoadingSpinner: {
-            style: {
-                height: '100%',
-                width: '100%',
-            },
+            component: StyledClipLoader,
+            style: [
+                __assign(__assign(__assign({ height: '100%', width: '100%' }, getLoaderMajorColor({ theme: theme }, { variant: variant })), getLoaderMinorColor({ theme: theme }, { variant: variant })), { animationName: {
+                        '0%': {
+                            transform: 'rotate(0deg) scale(1)',
+                        },
+                        '50%': {
+                            transform: 'rotate(180deg) scale(1)',
+                        },
+                        '100%': {
+                            transform: 'rotate(360deg) scale(1)',
+                        },
+                    } }),
+                'border-2',
+            ],
         },
         StartEnhancer: {
-            // This check should not be required. Overrides should first be merged and then converted for baseui.
-            // In Button we are converting overrides(that's when rtlCssJs gets applied) and then merging, which is wrong.
-            style: getStyle(isRTL ? 'ml-1' : 'mr-1'),
+            style: 'mr-1',
         },
         EndEnhancer: {
-            style: getStyle(isRTL ? 'mr-1' : 'ml-1'),
+            style: 'ml-1',
         },
     }, _pick(adaptedProps.overrides, 'BaseButton'));
     var _e = __read(useOverrides(overrides === null || overrides === void 0 ? void 0 : overrides.StatefulTooltip, DefaultStatefulTooltip), 2), StatefulTooltip = _e[0], statefulTooltipProps = _e[1];
     var buttonEl = (_jsx(BaseUIButton, __assign({ "data-spaceweb": "button", "data-testid": "button" }, adaptedProps, { onClick: adaptedProps.onClick, overrides: __assign(__assign({}, convertedOverrides), mergedOverrides), ref: buttonRef }), void 0));
     if (adaptedProps.disabled && tooltipContent) {
-        return (_jsx(DisabledTooltipContainer, __assign({ placement: "bottom", content: tooltipContent }, statefulTooltipProps, { children: buttonEl }), void 0));
+        return (_jsx(DisabledTooltipContainer, __assign({ placement: "bottom", content: tooltipContent, intent: intent, viewportAsBoundary: true }, statefulTooltipProps, { children: buttonEl }), void 0));
     }
-    return tooltipContent ? (_jsx(StatefulTooltip, __assign({ placement: "bottom", content: tooltipContent }, statefulTooltipProps, { children: buttonEl }), void 0)) : (buttonEl);
+    return tooltipContent ? (_jsx(StatefulTooltip, __assign({ placement: "bottom", content: tooltipContent, intent: intent, viewportAsBoundary: true }, statefulTooltipProps, { children: buttonEl }), void 0)) : (buttonEl);
 });
 Button.displayName = 'Button';
 export default Button;

package/esm/button/IconButton/IconButton.js

@@ -13,7 +13,13 @@ var IconButton = forwardRef(function (props, ref) {
     var overrides = mergeOverrides({
         BaseButton: {
             style: [iconButtonStyles, className, style],
-            props: { $bordered: bordered, $size: size, $isIconButton: true },
+            props: {
+                $bordered: bordered,
+                $size: size,
+                $isIconButton: true,
+                $intent: props.intent,
+                $variant: variant,
+            },
         },
     }, buttonProps.overrides);
     var ariaLabel = typeof buttonProps.tooltipContent === 'string' && !buttonProps.isLoading ? buttonProps.tooltipContent : undefined;

package/esm/button/IconButton/styled-components.d.ts

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { IconProps } from '../../icon';
 import { Styles } from '../../types';
+export declare const getBorderRadiiStyles: (utils: any, props: any) => import("styletron-standard").StyleObject | undefined;
 export declare const iconButtonStyles: Styles;
 export declare const renderIconButtonChild: (theme: any, size: any, child: React.ReactElement<IconProps>) => React.ReactElement<IconProps, string | React.JSXElementConstructor<any>> | null;

package/esm/button/IconButton/styled-components.js

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { getComponentSizeTheme } from '../../helpers/themeHelpers';
 import { borderRadius, padding } from '../../helpers/longHandHelpers';
-import { createButtonStyles } from '../styled-components';
+import { createButtonStyles, getStylesWithAnimatedBorder } from '../styled-components';
 var SHAPE_VS_THEME_KEY = {
     round: 'shapeRound',
     square: 'shapeSquare',
@@ -14,6 +14,17 @@ var getDimensions = function (_a, _b) {
     var size = getButtonSizeTheme(theme, $size).buttonSize;
     return { height: px2rem(size), width: px2rem(size) };
 };
+export var getBorderRadiiStyles = function (utils, props) {
+    var theme = utils.theme;
+    var $size = props.$size, $shape = props.$shape;
+    if ($shape !== 'square')
+        return undefined;
+    var squareButtonSizeRadius = getButtonSizeTheme(theme, $size).squareBorderRadius;
+    var squareBorderRadius = squareButtonSizeRadius
+        ? "".concat(squareButtonSizeRadius, "px")
+        : theme.iconButton.shapeSquare.borderRadius;
+    return borderRadius(squareBorderRadius);
+};
 var resetPadding = function (_a) {
     var theme = _a.theme;
     return padding(theme.padding['0']);
@@ -29,11 +40,32 @@ var makeGetStyleFromTheme = function (theme, shape, bordered) {
         return bordered ? (_b = iconButton["".concat(btnShapeKey, "Bordered")][btnStateKey]) !== null && _b !== void 0 ? _b : defaultColor : defaultColor;
     };
 };
-var getVariantStyles = function (_a, props) {
-    var theme = _a.theme;
-    var _b = props.$bordered, $bordered = _b === void 0 ? false : _b, _c = props.$shape, $shape = _c === void 0 ? 'round' : _c;
+var getAiIntentStyle = function (utils, props) {
+    var theme = utils.theme;
+    var $bordered = props.$bordered, $shape = props.$shape;
+    var aiIntentStyle = createButtonStyles({
+        color: theme.spr.icon01,
+        borderColor: theme.borderColor.transparent,
+        hoverBorderColor: theme.borderColor.transparent,
+        activeBorderColor: theme.borderColor.transparent,
+        disabledBorderColor: theme.borderColor.transparent,
+        backgroundColor: theme.spr.ui01,
+        hoverBackgroundColor: theme.spr.ui01,
+        activeBackgroundColor: theme.spr.ui01,
+        background: $bordered ? theme.ai.border01.background : undefined,
+        hoverBackground: theme.ai.border01.background,
+        activeBackground: "".concat(theme.ai.ui02, " padding-box , ").concat(theme.ai.ui01, " border-box"),
+        disabledBackground: theme.ai.border01.background,
+        disabledOpacity: '0.2',
+    }, props);
+    var borderRadiiStyles = ($shape === 'round' ? borderRadius('100%') : getBorderRadiiStyles(utils, props));
+    return getStylesWithAnimatedBorder(utils, props, aiIntentStyle, borderRadiiStyles);
+};
+var getIntentStyles = function (utils, props) {
+    var theme = utils.theme;
+    var _a = props.$bordered, $bordered = _a === void 0 ? false : _a, _b = props.$shape, $shape = _b === void 0 ? 'round' : _b, $intent = props.$intent;
     var styleFromThemeGetter = makeGetStyleFromTheme(theme, $shape, $bordered);
-    return createButtonStyles({
+    var defaultStyle = createButtonStyles({
         color: styleFromThemeGetter('color'),
         activeColor: styleFromThemeGetter('activeColor'),
         hoverColor: styleFromThemeGetter('hoverColor'),
@@ -47,22 +79,22 @@ var getVariantStyles = function (_a, props) {
         activeBackgroundColor: styleFromThemeGetter('activeBackgroundColor'),
         disabledBackgroundColor: styleFromThemeGetter('disabledBackgroundColor'),
     }, props);
+    switch ($intent) {
+        case 'ai':
+            return getAiIntentStyle(utils, props);
+        default:
+            return defaultStyle;
+    }
 };
 export var iconButtonStyles = [
     function (_a) {
         var theme = _a.theme;
         return ({ minWidth: theme.iconButton.minWidth });
     },
-    function (_a, _b) {
-        var theme = _a.theme;
-        var $shape = _b.$shape, $size = _b.$size;
-        var squareButtonSizeRadius = getButtonSizeTheme(theme, $size).squareBorderRadius;
-        var squareBorderRadius = squareButtonSizeRadius ? "".concat(squareButtonSizeRadius, "px") : theme.iconButton.shapeSquare.borderRadius;
-        return $shape === 'square' ? borderRadius(squareBorderRadius) : undefined;
-    },
+    getBorderRadiiStyles,
     resetPadding,
     getDimensions,
-    getVariantStyles,
+    getIntentStyles,
 ];
 export var renderIconButtonChild = function (theme, size, child) {
     return React.isValidElement(child)

package/esm/button/IconTextButton/IconTextButton.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 declare const IconTextButton: import("react").ForwardRefExoticComponent<Omit<import("..").ButtonProps, "variant"> & {
-    icon?: import("react").ComponentType<import("../../icon").IconProps> | undefined;
+    icon?: import("react").ComponentType<import("react").PropsWithChildren<import("../../icon").IconProps>> | undefined;
     variant?: import("./types").Variant | undefined;
     bordered?: boolean | undefined;
 } & import("react").RefAttributes<HTMLButtonElement>>;

package/esm/button/IconTextButton/types.d.ts

@@ -3,7 +3,7 @@ import { ButtonProps, ButtonSharedProps } from '../types';
 import { IconProps } from '../../icon';
 export declare type Variant = 'default' | 'bulk';
 export declare type IconTextButtonProps = Omit<ButtonProps, 'variant'> & {
-    icon?: ComponentType<IconProps>;
+    icon?: ComponentType<React.PropsWithChildren<IconProps>>;
     variant?: Variant;
     bordered?: boolean;
 };

package/esm/button/basewebAdapter.d.ts

@@ -6,27 +6,28 @@ declare const _default: (props: Omit<ButtonProps, 'size'>) => {
         readonly secondary: "secondary";
         readonly tertiary: "tertiary";
     }>;
+    children?: import("react").ReactNode;
     style?: import("..").Styles;
     disabled?: boolean | undefined;
     className?: import("..").Styles;
-    children?: import("react").ReactNode;
-    overrides?: import("./types").ButtonOverrides | undefined;
-    autoFocus?: boolean | undefined;
+    animate?: boolean | undefined;
     href?: string | undefined;
-    rel?: string | undefined;
     shape?: import("./types").Shape | undefined;
     target?: string | undefined;
     type?: "button" | "reset" | "submit" | undefined;
+    autoFocus?: boolean | undefined;
     tabIndex?: number | undefined;
     role?: import("react").AriaRole | undefined;
+    rel?: string | undefined;
     onClick?: ((event: import("react").MouseEvent<HTMLElement, MouseEvent>) => any) | undefined;
     $as?: import("react").ElementType<any> | undefined;
-    startEnhancer?: import("react").ReactNode;
-    endEnhancer?: import("react").ReactNode;
-    tooltipContent?: import("react").ReactNode | import("baseui/popover").StatefulContentRenderProp;
+    overrides?: import("./types").ButtonOverrides | undefined;
     intent?: import("..").Intent | undefined;
     isLoading?: boolean | undefined;
     isSelected?: boolean | undefined;
+    startEnhancer?: import("react").ReactNode | import("react").ComponentType<any>;
+    endEnhancer?: import("react").ReactNode | import("react").ComponentType<any>;
     fullWidth?: boolean | undefined;
+    tooltipContent?: import("react").ReactNode | import("../baseui/popover").ContentRenderProp;
 };
 export default _default;

package/esm/button/basewebAdapter.js

@@ -1,5 +1,5 @@
 import { __assign } from "tslib";
-import { KIND } from 'baseui/button';
+import { KIND } from '../baseui/button';
 import _omit from 'lodash/omit';
 var variantMap = {
     primary: KIND.primary,

package/esm/button/index.d.ts

@@ -1,5 +1,5 @@
 export { default as Button } from './Button';
 export { default as IconButton } from './IconButton';
 export { default as IconTextButton } from './IconTextButton';
-export { StyledStartEnhancer, StyledEndEnhancer, StyledLoadingSpinner, StyledLoadingSpinnerContainer, } from 'baseui/button';
+export { StyledStartEnhancer, StyledEndEnhancer, StyledLoadingSpinner, StyledLoadingSpinnerContainer, } from '../baseui/button';
 export type { ButtonProps, Shape, ButtonSharedProps, Size, ButtonOverrides } from './types';

package/esm/button/index.js

@@ -1,4 +1,4 @@
 export { default as Button } from './Button';
 export { default as IconButton } from './IconButton';
 export { default as IconTextButton } from './IconTextButton';
-export { StyledStartEnhancer, StyledEndEnhancer, StyledLoadingSpinner, StyledLoadingSpinnerContainer, } from 'baseui/button';
+export { StyledStartEnhancer, StyledEndEnhancer, StyledLoadingSpinner, StyledLoadingSpinnerContainer, } from '../baseui/button';

package/esm/button/styled-components.d.ts

@@ -1,4 +1,4 @@
-import { StyleObject, Styles } from '../types';
+import { StyleFn, StyleObject, Styles, StyleUtils } from '../types';
 import { ButtonSharedProps } from './types';
 declare type ButtonStyleParams = {
     color: string;
@@ -13,8 +13,33 @@ declare type ButtonStyleParams = {
     hoverBorderColor?: string;
     activeBorderColor?: string;
     disabledBorderColor?: string;
+    background?: string;
+    hoverBackground?: string;
+    activeBackground?: string;
+    disabledBackground?: string;
+    hoverOpacity?: string;
+    activeOpacity?: string;
+    disabledOpacity?: string;
 };
-export declare const createButtonStyles: ({ color, hoverColor, activeColor, disabledColor, backgroundColor, disabledBackgroundColor, hoverBackgroundColor, activeBackgroundColor, borderColor, hoverBorderColor, activeBorderColor, disabledBorderColor, }: ButtonStyleParams, { $disabled, $isSelected, $isFocusVisible }: ButtonSharedProps) => StyleObject;
+export declare const createButtonStyles: ({ color, hoverColor, activeColor, disabledColor, backgroundColor, disabledBackgroundColor, hoverBackgroundColor, activeBackgroundColor, borderColor, hoverBorderColor, activeBorderColor, disabledBorderColor, background, hoverBackground, activeBackground, disabledBackground, hoverOpacity, activeOpacity, disabledOpacity, }: ButtonStyleParams, { $disabled, $isSelected, $isFocusVisible }: ButtonSharedProps) => StyleObject;
+export declare const getSprinklrAIAnimatedBorderStyles: StyleFn;
+export declare const getStylesWithAnimatedBorder: (utils: StyleUtils, props: ButtonSharedProps, initialStyles: StyleObject, borderRadiiStyles: StyleObject) => StyleObject;
 export declare const getButtonStyles: Styles;
 export declare const StyledLoadingSpinnerContainer: import("../style/styled").StyledComponent;
+export declare const getLoaderMajorColor: ({ theme }: {
+    theme: any;
+}, { variant }: {
+    variant: any;
+}) => {
+    borderTopColor: any;
+    borderLeftColor: any;
+    borderRightColor: any;
+};
+export declare const getLoaderMinorColor: ({ theme }: {
+    theme: any;
+}, { variant }: {
+    variant: any;
+}) => {
+    borderBottomColor: any;
+};
 export {};