@ringcentral/spring-ui 1.11.2 → 1.13.0

package/VirtualizedMenu.js

@@ -1,29 +1,359 @@
-export { a as VirtualizedMenu, V as VirtualizedMenuContext, b as VirtualizedMenuList, u as useVirtualizedMenuContext } from './chunks/VirtualizedMenu.js';
-import 'react/jsx-runtime';
-import 'react';
-import '@ringcentral/spring-base';
-import '@ringcentral/spring-theme';
-import 'clsx';
-import './chunks/useAnimationFrame.js';
-import './chunks/Popover.js';
-import '@floating-ui/react-dom';
-import 'framer-motion';
-import './chunks/Icon.js';
-import './chunks/usePrefersReducedMotion.js';
-import './chunks/getGrow.js';
-import './chunks/Modal.js';
-import '@mui/base';
-import './chunks/getFade.js';
-import './chunks/useFocusTrapStack.js';
-import './chunks/Backdrop.js';
-import './Popper.js';
-import './chunks/PopperPaper.js';
-import './VirtualizedList.js';
-import 'react-virtuoso';
-import './chunks/List.js';
-import './chunks/useListNavigation.js';
-import 'tabbable';
-
-var VirtualizedMenu = {"sui-virtualized-menu-paper":"sui-virtualized-menu-paper","sui-virtualized-menu-paper-content-container":"sui-virtualized-menu-paper-content-container","sui-virtualized-menu-list":"sui-virtualized-menu-list"};
-
-export { VirtualizedMenu as virtualizedMenuStyle };
+import { createContext, forwardRef, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { combineProps, useClasses, useEventCallback, useForkRef } from "@ringcentral/spring-base";
+import { useThemeProps } from "@ringcentral/spring-theme";
+import { VirtualizedList } from "./VirtualizedList.js";
+import { useAnimationFrame } from "./chunks/6335.js";
+import { Popover as Popover_Popover } from "./Popover.js";
+
+
+
+const VirtualizedMenuContext = createContext(null);
+const useVirtualizedMenuContext = ()=>useContext(VirtualizedMenuContext);
+
+
+
+
+
+// extracted by css-extract-rspack-plugin
+/* export default */ var VirtualizedMenu = ({"sui-virtualized-menu-paper":"sui-virtualized-menu-paper","sui-virtualized-menu-paper-content-container":"sui-virtualized-menu-paper-content-container","sui-virtualized-menu-list":"sui-virtualized-menu-list"});
+
+
+
+
+
+
+
+
+const VirtualizedMenuList = (props)=>{
+    const { children, actions: actionsProp, initialFocus: initialFocusProps, totalListHeightChanged: totalListHeightChangedProp, ...rest } = props;
+    const actions = useRef(null);
+    const handleListActions = useForkRef(actions, actionsProp);
+    const listRef = useRef(null);
+    const virtualizedMenuContext = useVirtualizedMenuContext();
+    useLayoutEffect(()=>{
+        if (!virtualizedMenuContext?.open) {
+            return;
+        }
+        const initialFocus = typeof initialFocusProps === 'function' ? initialFocusProps() : initialFocusProps;
+        if (initialFocus === true) {
+            actions.current?.focus();
+        } else if (typeof initialFocus === 'number') {
+            actions.current?.focusByIndex(initialFocus);
+        }
+    // oxlint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        virtualizedMenuContext?.open
+    ]);
+    return /*#__PURE__*/ jsx(VirtualizedList, {
+        actions: handleListActions,
+        ...rest,
+        ListProps: combineProps({
+            role: 'menu'
+        }, rest.ListProps),
+        ref: listRef,
+        totalListHeightChanged: totalListHeightChangedProp,
+        children: children
+    });
+};
+
+
+
+
+
+
+
+
+
+
+const MENU_VERTICAL_PADDING = 8;
+/** Reach `measureDesiredHeight` without putting it on public `PopoverProps`. */ const InternalPopover = Popover_Popover;
+const isEmptyVirtualizedData = (data, totalCount)=>totalCount === 0 || totalCount === undefined && data !== undefined && data.length === 0;
+const VirtualizedMenu_VirtualizedMenu = /*#__PURE__*/ forwardRef((inProps, ref)=>{
+    const props = useThemeProps({
+        props: inProps,
+        name: 'VirtualizedMenu'
+    });
+    const { classes, className, children, open, onClose, onAfterClose, data, totalCount, isItemDisabled, actions, VirtualizedListProps, popperActions: popperActionsProp, initialFocus = true, maxHeight, PopperProps, ...rest } = props;
+    const paperContentContainerRef = useRef(null);
+    const hasItemsRenderedRef = useRef(false);
+    /** Whether the container currently holds the height used to pick a side. */ const isHoldingPlacementHeightRef = useRef(false);
+    const [waitForHeightCompute, setWaitForHeightCompute] = useState(true);
+    const [menuHeight, setMenuHeight] = useState(MENU_VERTICAL_PADDING * 2);
+    /**
+     * Number of times the placement measurement has been asked to release. This
+     * is a counter rather than a boolean on purpose: the request is raised from
+     * Popover's `size` middleware, which can run in the same React batch that
+     * started the measurement. A boolean would collapse to "nothing changed" and
+     * strand the inline height on the container forever.
+     */ const [placementHeightReleases, setPlacementHeightReleases] = useState(0);
+    const [deferPendingVirtualizedListActions, setDeferPendingVirtualizedListActions] = useState(true);
+    const computedListHeight = useRef(-1);
+    const availableHeight = useRef(-1);
+    const cls = useClasses('virtualized-menu', classes, className);
+    const padding = PopperProps?.padding;
+    const popperPadding = typeof padding === 'object' ? {
+        top: padding.top ?? 16,
+        right: padding.right ?? 16,
+        bottom: padding.bottom ?? 16,
+        left: padding.left ?? 16
+    } : padding ?? 16;
+    const popperActions = useRef(null);
+    const handlePopperActions = useForkRef(popperActions, popperActionsProp);
+    const { requestAnimationFrame } = useAnimationFrame();
+    /**
+     * Give the container back to the list. Only safe once the clamped height has
+     * been committed to the list, otherwise the menu collapses to the list's
+     * previous height while Floating UI is still positioning it.
+     */ const releasePlacementHeight = useEventCallback(()=>{
+        isHoldingPlacementHeightRef.current = false;
+        if (paperContentContainerRef.current) {
+            paperContentContainerRef.current.style.height = '';
+        }
+    });
+    const resetLayoutCache = useEventCallback(()=>{
+        hasItemsRenderedRef.current = false;
+        computedListHeight.current = -1;
+        availableHeight.current = -1;
+        releasePlacementHeight();
+        setMenuHeight(MENU_VERTICAL_PADDING * 2);
+        setWaitForHeightCompute(true);
+        setDeferPendingVirtualizedListActions(true);
+    });
+    const menuContextValue = useMemo(()=>{
+        return {
+            open
+        };
+    }, [
+        open
+    ]);
+    const handleAfterClose = useEventCallback(()=>{
+        resetLayoutCache();
+        onAfterClose?.();
+    });
+    const updateMenuHeight = useEventCallback(()=>{
+        let computedMenuHeight = computedListHeight.current;
+        // availableHeight stays -1 until Popper reports space; do not clamp against it yet
+        if (availableHeight.current !== -1 && computedMenuHeight > availableHeight.current) {
+            computedMenuHeight = availableHeight.current;
+        }
+        if (maxHeight !== undefined && computedMenuHeight > maxHeight) {
+            computedMenuHeight = maxHeight;
+        }
+        setMenuHeight(computedMenuHeight);
+    });
+    /**
+     * Write the height the list actually wants onto the container and report it as
+     * Popover's desired height. The list's scroll viewport is sized from state, so
+     * dropping Popover's clamp cannot grow it back: without this, `flip` would only
+     * ever measure the viewport-clamped height from the previous pass — including
+     * window resize, where Virtuoso does not re-report total height. Only the public
+     * `maxHeight` caps it.
+     */ const holdPlacementHeight = useEventCallback(()=>{
+        if (computedListHeight.current === -1 || !hasItemsRenderedRef.current || !paperContentContainerRef.current) {
+            return undefined;
+        }
+        const placementHeight = maxHeight !== undefined ? Math.min(computedListHeight.current, maxHeight) : computedListHeight.current;
+        paperContentContainerRef.current.style.height = `${placementHeight}px`;
+        isHoldingPlacementHeightRef.current = true;
+        return placementHeight;
+    });
+    const applyListHeight = useEventCallback((listHeight)=>{
+        /**
+       * Virtuoso reports height without the ::before/::after pseudo-element padding.
+       * Add padding to match the actual rendered height (same approach as SuggestionList).
+       */ const adjustedHeight =  true ? listHeight + MENU_VERTICAL_PADDING * 2 : 0;
+        computedListHeight.current = adjustedHeight;
+        updateMenuHeight();
+        popperActions.current?.update();
+    });
+    const revealWhenSettled = useEventCallback(()=>{
+        /**
+       * Perform all pending actions once we know the list height has settled. This is necessary
+       * as those pending actions expect the list to have fully rendered before they can be ran.
+       */ requestAnimationFrame(()=>{
+            setDeferPendingVirtualizedListActions(false);
+            /**
+         * Wait for the next repaint to ensure the pending actions have been completed and the height
+         * has been computed and painted. If we didn't do this, the menu could flicker if the initial
+         * scroll position was set to a value that would cause the list to scroll down.
+         */ requestAnimationFrame(()=>{
+                setWaitForHeightCompute(false);
+            });
+        });
+    });
+    const handleTotalListHeightChanged = useEventCallback((listHeight)=>{
+        /**
+       * Only process height after items have been rendered. This prevents using incomplete
+       * measurements before Virtuoso has actually rendered list content, avoiding flicker
+       * and incorrect placement (same approach as SuggestionList).
+       */ if (!hasItemsRenderedRef.current) {
+            return;
+        }
+        applyListHeight(listHeight);
+        if (waitForHeightCompute) {
+            revealWhenSettled();
+        }
+    });
+    const handleAvailableHeightChange = useEventCallback((value)=>{
+        /**
+       * Ignore available height updates until the list has been computed and items rendered.
+       * This prevents applying constraints to an incomplete list during initial render.
+       */ if (computedListHeight.current === -1 || !hasItemsRenderedRef.current) {
+            return;
+        }
+        availableHeight.current = value;
+        updateMenuHeight();
+        /**
+       * The measurement cannot be released here. `updateMenuHeight` only schedules a
+       * render, so the list still has its old height in the DOM: clearing the container
+       * now would collapse the menu in the middle of Popover's `size` middleware, and
+       * the pass that follows would measure a nearly empty menu and settle on the wrong
+       * side. Hand it to a layout effect, which runs once the new height is committed.
+       */ if (isHoldingPlacementHeightRef.current) {
+            isHoldingPlacementHeightRef.current = false;
+            setPlacementHeightReleases((count)=>count + 1);
+        }
+    });
+    /**
+     * Drop the measurement hold once the list height has committed. Do not call
+     * `popper.update()` here: the pass that held for `flip` already finished, and
+     * another update would hold again → release → update forever on resize.
+     */ useLayoutEffect(()=>{
+        if (placementHeightReleases === 0) {
+            return;
+        }
+        releasePlacementHeight();
+    }, [
+        placementHeightReleases,
+        releasePlacementHeight
+    ]);
+    useEffect(()=>{
+        if (!open) {
+            hasItemsRenderedRef.current = false;
+            // Never carry a held measurement across a close, otherwise a menu closed
+            // mid-measurement would reopen with an oversized container.
+            releasePlacementHeight();
+        // Keep computedListHeight / availableHeight while the list stays mounted
+        // (close animation / rapid toggle). They are reset in resetLayoutCache
+        // once the Popover content has actually left the DOM.
+        }
+        /**
+       * Keep Popover's enter animation held until Virtuoso reports list height, so
+       * the menu only becomes visible on the correct flip side (not a too-short
+       * pre-list placement). After that, Popover auto-update handles resize and
+       * growth.
+       */ if (open) {
+            // Reuse preserved height from previous render during rapid toggling (component reuse).
+            // This avoids the minimum height flash and eliminates dependency on Virtuoso re-reporting height.
+            if (computedListHeight.current !== -1) {
+                updateMenuHeight();
+                setWaitForHeightCompute(false);
+                setDeferPendingVirtualizedListActions(false);
+                // Trigger Popper update to recalculate availableHeight (e.g., window resize).
+                // Ensures handleAvailableHeightChange is called even if Virtuoso skips callbacks.
+                popperActions.current?.update();
+            } else {
+                setMenuHeight(MENU_VERTICAL_PADDING * 2); // initial height for the menu
+                setWaitForHeightCompute(true);
+                setDeferPendingVirtualizedListActions(true);
+            }
+        }
+    // oxlint-disable-next-line react-hooks/exhaustive-deps -- stable useEventCallback refs; run on open toggle only
+    }, [
+        open
+    ]);
+    const isEmptyList = isEmptyVirtualizedData(data, totalCount);
+    useEffect(()=>{
+        if (!open || !isEmptyList) {
+            return;
+        }
+        /**
+       * Virtuoso often skips `totalListHeightChanged` for empty lists. Settle once
+       * from emptiness, not from every `itemsRendered`, so empty menus still clear
+       * `waitForHeightCompute` (which releases the enter animation) and land on
+       * padding-only height.
+       */ hasItemsRenderedRef.current = true;
+        applyListHeight(0);
+        revealWhenSettled();
+    // oxlint-disable-next-line react-hooks/exhaustive-deps -- stable useEventCallback refs; run when empty list opens
+    }, [
+        open,
+        isEmptyList
+    ]);
+    return /*#__PURE__*/ jsx(InternalPopover, {
+        bordered: true,
+        PopperProps: {
+            ...PopperProps,
+            padding: popperPadding
+        },
+        ...rest,
+        open: open,
+        className: cls('root'),
+        onClose: onClose,
+        onAfterClose: handleAfterClose,
+        onAvailableHeightChange: handleAvailableHeightChange,
+        deferEnterAnimation: waitForHeightCompute,
+        measureDesiredHeight: holdPlacementHeight,
+        disableContentVerticalScroll: true,
+        ref: ref,
+        // disable animation. The Grow animation will cause vl height calculate incorrectly
+        motionProps: {
+            variants: undefined
+        },
+        actions: handlePopperActions,
+        children: /*#__PURE__*/ jsx("div", {
+            className: cls('paper'),
+            children: /*#__PURE__*/ jsx("div", {
+                ref: paperContentContainerRef,
+                className: cls('paper-content-container'),
+                children: /*#__PURE__*/ jsx(VirtualizedMenuContext.Provider, {
+                    value: menuContextValue,
+                    children: /*#__PURE__*/ jsx(VirtualizedMenuList, {
+                        data: data,
+                        totalCount: totalCount,
+                        isReady: !deferPendingVirtualizedListActions,
+                        isItemDisabled: isItemDisabled,
+                        initialFocus: initialFocus,
+                        actions: actions,
+                        ...combineProps(VirtualizedListProps, {
+                            style: {
+                                height: menuHeight
+                            },
+                            ListProps: combineProps(VirtualizedListProps?.ListProps, {
+                                className: cls('list'),
+                                style: {
+                                    ['--sui-virtualized-menu-vertical-padding']: `${MENU_VERTICAL_PADDING}px`
+                                }
+                            }),
+                            totalListHeightChanged: handleTotalListHeightChanged,
+                            itemsRendered: (items)=>{
+                                if (items && items.length > 0) {
+                                    hasItemsRenderedRef.current = true;
+                                }
+                                VirtualizedListProps?.itemsRendered?.(items);
+                            },
+                            onKeyDown: (e)=>{
+                                if (e.key === 'Tab') {
+                                    e.preventDefault();
+                                    onClose?.();
+                                }
+                            }
+                        }),
+                        children: children
+                    })
+                })
+            })
+        })
+    });
+});
+VirtualizedMenu_VirtualizedMenu.displayName = 'SuiVirtualizedMenu';
+
+
+
+
+
+
+
+
+export { VirtualizedMenu as virtualizedMenuStyle, VirtualizedMenuContext, VirtualizedMenuList, VirtualizedMenu_VirtualizedMenu as VirtualizedMenu, useVirtualizedMenuContext };

package/VisuallyHidden.js

@@ -1,8 +1,31 @@
-export { V as VisuallyHidden } from './chunks/VisuallyHidden.js';
-import 'react/jsx-runtime';
-import 'react';
-import '@ringcentral/spring-base';
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { useClasses } from "@ringcentral/spring-base";
 
-var VisuallyHidden = {"sui-visually-hidden-root":"sui-visually-hidden-root"};
 
-export { VisuallyHidden as visuallyHiddenStyle };
+
+
+// extracted by css-extract-rspack-plugin
+/* export default */ var VisuallyHidden = ({"sui-visually-hidden-root":"sui-visually-hidden-root"});
+
+
+
+
+const VisuallyHidden_VisuallyHidden = /*#__PURE__*/ forwardRef((props, ref)=>{
+    const { classes, className, children, ...rest } = props;
+    const cls = useClasses('visually-hidden', classes, className);
+    return /*#__PURE__*/ jsx("span", {
+        className: cls('root'),
+        ...rest,
+        ref: ref,
+        children: children
+    });
+});
+VisuallyHidden_VisuallyHidden.displayName = 'SuiVisuallyHidden';
+
+
+
+
+
+
+export { VisuallyHidden as visuallyHiddenStyle, VisuallyHidden_VisuallyHidden as VisuallyHidden };

package/chunks/1250.js

@@ -0,0 +1,98 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import react, { cloneElement, forwardRef, isValidElement } from "react";
+import { useClasses, useId } from "@ringcentral/spring-base";
+import { useThemeProps } from "@ringcentral/spring-theme";
+
+
+
+
+
+// extracted by css-extract-rspack-plugin
+/* export default */ var Squircle = ({"sui-squircle-root":"sui-squircle-root","sui-squircle-interactive":"sui-squircle-interactive","sui-active":"sui-active","sui-squircle-content":"sui-squircle-content","sui-squircle-ring":"sui-squircle-ring"});
+
+
+
+
+
+const SQUIRCLE_PATH = 'M 0.5 0 C 0.879 0 1 0.121 1 0.5 C 1 0.879 0.879 1 0.5 1 C 0.121 1 0 0.879 0 0.5 C 0 0.121 0.121 0 0.5 0 Z';
+const Squircle_Squircle = /*#__PURE__*/ forwardRef((inProps, ref)=>{
+    const props = useThemeProps({
+        props: inProps,
+        name: 'Squircle'
+    });
+    const { component = 'div', focusVisible, active, children: childrenProp, className, classes, interactive = true, fillShape: fillShapeProp = false, ...rest } = props;
+    /**
+     * If the children passed to this component have a conditionally rendered
+     * element, using toArray will ensure that any falsy children are removed.
+     * Otherwise fillShape will always be false even if only 1 truthy child
+     * is passed to this component.
+     */ const children = react.Children.toArray(childrenProp);
+    const firstChild = children[0];
+    const fillShape = fillShapeProp && firstChild && // oxlint-disable-next-line @typescript-eslint/no-explicit-any
+    /*#__PURE__*/ isValidElement(firstChild);
+    const cls = useClasses('squircle', classes, className);
+    const clipId = useId('sui-squircle-clip', true);
+    const showFocusRing = interactive && focusVisible;
+    const Root = component;
+    return /*#__PURE__*/ jsxs(Root, {
+        className: cls('root', {
+            active,
+            interactive
+        }),
+        ...rest,
+        ref: ref,
+        children: [
+            /*#__PURE__*/ jsx("svg", {
+                xmlns: "http://www.w3.org/2000/svg",
+                width: "0",
+                height: "0",
+                viewBox: "0 0 1 1",
+                style: {
+                    position: 'absolute'
+                },
+                "aria-hidden": true,
+                children: /*#__PURE__*/ jsx("defs", {
+                    children: /*#__PURE__*/ jsx("clipPath", {
+                        id: clipId,
+                        clipPathUnits: "objectBoundingBox",
+                        children: /*#__PURE__*/ jsx("path", {
+                            d: SQUIRCLE_PATH
+                        })
+                    })
+                })
+            }),
+            !fillShape && /*#__PURE__*/ jsx("svg", {
+                className: cls('content'),
+                xmlns: "http://www.w3.org/2000/svg",
+                viewBox: '0 0 1 1',
+                children: /*#__PURE__*/ jsx("path", {
+                    clipPath: `url(#${clipId})`,
+                    d: SQUIRCLE_PATH,
+                    vectorEffect: "non-scaling-stroke"
+                })
+            }),
+            showFocusRing && /*#__PURE__*/ jsx("svg", {
+                className: cls('ring'),
+                xmlns: "http://www.w3.org/2000/svg",
+                viewBox: "0 0 1 1",
+                overflow: "visible",
+                children: /*#__PURE__*/ jsx("path", {
+                    d: SQUIRCLE_PATH,
+                    fillOpacity: 0,
+                    vectorEffect: "non-scaling-stroke"
+                })
+            }),
+            fillShape ? /*#__PURE__*/ cloneElement(firstChild, {
+                style: {
+                    ...firstChild.props.style,
+                    width: '100%',
+                    height: '100%',
+                    clipPath: `url(#${clipId})`
+                }
+            }) : children
+        ]
+    });
+});
+
+
+export { Squircle as squircleStyle, Squircle_Squircle as Squircle };

package/chunks/1294.js

@@ -0,0 +1,126 @@
+import { jsx } from "react/jsx-runtime";
+import { MotionConfigContext, motion } from "framer-motion";
+import { useClasses, useGlobalListener } from "@ringcentral/spring-base";
+import { motionTransition } from "@ringcentral/spring-theme";
+import { useContext, useState } from "react";
+import { Icon as Icon_Icon } from "./8307.js";
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * in all component that uses this hook, we always use same instance of MediaQueryList
+ * so we can cache the instance here
+ */ let instance;
+const getPrefersReducedMotionMediaQuery = ()=>{
+    if (!instance || // in test environment, we need to reassign the instance to the window object
+    process.env.NODE_ENV === 'test') {
+        instance = window?.matchMedia?.('(prefers-reduced-motion)');
+    }
+    return instance;
+};
+const usePrefersReducedMotion = ()=>{
+    const mediaQuery = getPrefersReducedMotionMediaQuery();
+    const [shouldReduceMotion, setShouldReduceMotion] = useState(mediaQuery?.matches || false);
+    const context = useContext(MotionConfigContext);
+    useGlobalListener('change', (event)=>{
+        setShouldReduceMotion(event.matches);
+    }, {
+        target: mediaQuery,
+        customKey: 'prefers-reduced-motion'
+    });
+    /**
+   * As we're determining the reduced motion state ourselves after the initial mount,
+   * we need to check the MotionConfigContext to see how the prefers-reduced-motion
+   * state should be handled.
+   */ if (context.reducedMotion === 'user') {
+        // When explicitly set to 'user', respect the media query even in test environment
+        return shouldReduceMotion;
+    }
+    if (context.reducedMotion === 'always' || // In test environment, we always enable reduced motion to skip animations.
+    // Note: This overrides the default 'never' setting from MotionConfigContext.
+    process.env.NODE_ENV === 'test') {
+        return true;
+    }
+    // In production, respect the 'never' setting
+    if (context.reducedMotion === 'never') {
+        return false;
+    }
+    return shouldReduceMotion;
+};
+
+
+
+
+
+
+/**
+ * A hook that returns an instant transition if the user has reduced motion enabled.
+ * If reduced motion is not enabled, returns the given motion transition.
+ *
+ * Note: We use instant transition (duration: 0) instead of relying on framer-motion's
+ * reducedMotion setting because framer-motion only disables transform/layout animations,
+ * but opacity/backgroundColor animations persist.
+ */ const useMotionSafeTransition = (transition)=>{
+    const prefersReducedMotion = usePrefersReducedMotion();
+    return prefersReducedMotion ? motionTransition.instant : transition;
+};
+
+
+
+
+
+
+// extracted by css-extract-rspack-plugin
+/* export default */ var ExpandCollapseCaret = ({"sui-expand-collapse-caret-root":"sui-expand-collapse-caret-root","sui-expand-collapse-caret-vertical":"sui-expand-collapse-caret-vertical","sui-expand-collapse-caret-horizontal":"sui-expand-collapse-caret-horizontal"});
+
+
+
+
+
+
+
+const motionVariants = {
+    expanded: {
+        d: 'M 4.5 12.8 L 9.85 7.525 L 15.1 12.8'
+    },
+    collapsed: {
+        d: 'M 4.5 7.5 L 9.85 12.9 L 15.15 7.55'
+    }
+};
+const ExpandCollapseCaret_ExpandCollapseCaret = (props)=>{
+    const { size = 'small', orientation = 'vertical', expanded, classes, className, ...rest } = props;
+    const cls = useClasses('expand-collapse-caret', classes, className);
+    const transition = useMotionSafeTransition(motionTransition["spring-01-fast"]);
+    return /*#__PURE__*/ jsx(Icon_Icon, {
+        ...rest,
+        size: size,
+        className: cls('root', orientation),
+        children: /*#__PURE__*/ jsx(motion.svg, {
+            xmlns: "http://www.w3.org/2000/svg",
+            viewBox: '0 0 20 20',
+            children: /*#__PURE__*/ jsx(motion.path, {
+                initial: false,
+                stroke: "currentColor",
+                strokeWidth: 1.5,
+                variants: motionVariants,
+                animate: expanded ? 'expanded' : 'collapsed',
+                transition: transition,
+                fill: "transparent"
+            })
+        })
+    });
+};
+
+
+
+
+
+export { ExpandCollapseCaret as expandCollapseCaretStyles, ExpandCollapseCaret_ExpandCollapseCaret as ExpandCollapseCaret, useMotionSafeTransition, usePrefersReducedMotion };

package/chunks/2956.js

@@ -0,0 +1,18 @@
+import { createContext, useContext } from "react";
+
+
+
+/**
+ * Provides information about the current step in Stepper.
+ */ const StepContext = createContext({});
+/**
+ * Returns the current StepContext or an empty object if no StepContext
+ * has been defined in the component tree.
+ */ const useStepContext = ()=>useContext(StepContext);
+
+
+
+const StepperContext = createContext({});
+const useStepperContext = ()=>useContext(StepperContext);
+
+export { StepContext, StepperContext, useStepContext, useStepperContext };