@ringcentral/spring-ui 1.12.0 → 1.13.0

package/chunks/Tooltip.js

@@ -1,217 +0,0 @@
-import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
-import { useThemeProps } from '@ringcentral/spring-theme';
-import { AnimatePresence } from 'framer-motion';
-import { useRef, useEffect, cloneElement, forwardRef } from 'react';
-import { logInDev, useWindowContext, useId, useControlled, useIsFocusVisible, useForkRef, useEventListener, useClasses, combineProps } from '@ringcentral/spring-base';
-import clsx from 'clsx';
-import { I as Icon } from './Icon.js';
-import { u as usePrefersReducedMotion } from './usePrefersReducedMotion.js';
-import { g as getFade } from './getFade.js';
-import { Popper } from '../Popper.js';
-import { P as PopperPaper } from './PopperPaper.js';
-
-const ARIA_DESCRIBEDBY = 'aria-describedby';
-const ARIA_LABEL = 'aria-label';
-const ARIA_LABELLEDBY = 'aria-labelledby';
-const HTML_TITLE = 'title';
-let hasWarnedTriggerWhenDisabledNonStringTitle = false;
-function computeTooltipA11y({ title, describeChild, triggerWhenDisabled, open, tooltipId, child, }) {
-    const nameOrDescProps = {};
-    const disabledOverrides = {};
-    const titleIsString = typeof title === 'string';
-    const childProps = child.props;
-    const hasAriaDescribedBy = ARIA_DESCRIBEDBY in childProps;
-    const hasAriaLabel = ARIA_LABEL in childProps;
-    const hasAriaLabelledBy = ARIA_LABELLEDBY in childProps;
-    const hasUserTitle = HTML_TITLE in childProps;
-    if (process.env.NODE_ENV !== 'production' &&
-        triggerWhenDisabled &&
-        !titleIsString &&
-        title != null &&
-        !hasUserTitle &&
-        !hasWarnedTriggerWhenDisabledNonStringTitle) {
-        hasWarnedTriggerWhenDisabledNonStringTitle = true;
-        logInDev({
-            scope: 'Tooltip',
-            level: 'warn',
-            message: 'Using Tooltip with `triggerWhenDisabled` and a non-string `title` is not fully accessible. Use a string `title` when explaining why a control is disabled.',
-        });
-    }
-    if (describeChild) {
-        if (!hasAriaDescribedBy) {
-            if (!hasUserTitle) {
-                nameOrDescProps.title =
-                    !open && titleIsString ? title : null;
-            }
-            else if (open) {
-                nameOrDescProps.title = null;
-            }
-            nameOrDescProps[ARIA_DESCRIBEDBY] = open ? tooltipId : null;
-        }
-    }
-    else {
-        if (titleIsString && !hasAriaLabel) {
-            nameOrDescProps[ARIA_LABEL] = title;
-            nameOrDescProps.title = null;
-        }
-        else if (!titleIsString && !hasAriaLabelledBy && title) {
-            nameOrDescProps[ARIA_LABELLEDBY] = open ? tooltipId : null;
-            if (open) {
-                nameOrDescProps.title = null;
-            }
-        }
-        else if (open) {
-            nameOrDescProps.title = null;
-        }
-    }
-    if (triggerWhenDisabled) {
-        if (open) {
-            if (!hasAriaDescribedBy) {
-                disabledOverrides[ARIA_DESCRIBEDBY] = tooltipId;
-            }
-            disabledOverrides.title = null;
-        }
-        else if (titleIsString) {
-            disabledOverrides.title = title;
-        }
-    }
-    return { nameOrDescProps, disabledOverrides };
-}
-
-const getDelayTime = (delay) => {
-    if (!delay)
-        return null;
-    if (delay === true)
-        return 1500;
-    return delay;
-};
-const TooltipTrigger = (props, ref) => {
-    const { renderTooltip, children, open: openProp, delay = false, onOpenStateChange, triggerWhenDisabled, triggerWrapperProps, disableFocusListener, tooltipId: tooltipIdProp, title, describeChild = false, } = props;
-    const anchorRef = useRef(null);
-    const didInitiateWithTouch = useRef(false);
-    const { document } = useWindowContext();
-    const generatedId = useId();
-    const tooltipId = tooltipIdProp ?? generatedId;
-    const [open, setOpen] = useControlled({
-        controlled: openProp,
-        default: false,
-        name: 'Tooltip',
-        state: 'open',
-    });
-    const { isFocusVisibleRef, onFocus: handleFocusVisible, onBlur: handleBlurVisible, ref: focusVisibleRef, } = useIsFocusVisible();
-    const handleAnchorRef = useForkRef(anchorRef, focusVisibleRef, children.ref);
-    const delayTimerRef = useRef();
-    useEffect(() => () => {
-        clearTimeout(delayTimerRef.current);
-    }, []);
-    const handleOpen = (e) => {
-        const delayTime = getDelayTime(delay);
-        if (delayTime) {
-            delayTimerRef.current = setTimeout(() => {
-                setOpen(true);
-                onOpenStateChange?.(e, true);
-            }, delayTime);
-        }
-        else {
-            setOpen(true);
-            onOpenStateChange?.(e, true);
-        }
-    };
-    const handleClose = (e) => {
-        clearTimeout(delayTimerRef.current);
-        delayTimerRef.current = undefined;
-        setOpen(false);
-        onOpenStateChange?.(e, false);
-    };
-    useEventListener(anchorRef, 'mouseenter', (e) => {
-        if (didInitiateWithTouch.current) {
-            didInitiateWithTouch.current = false;
-            return;
-        }
-        if (anchorRef.current) {
-            anchorRef.current.removeAttribute('title');
-        }
-        handleOpen(e);
-    });
-    useEventListener(anchorRef, 'mouseleave', (e) => {
-        handleClose(e);
-    });
-    useEventListener(anchorRef, 'touchstart', (e) => {
-        didInitiateWithTouch.current = true;
-    }, {
-        passive: true,
-    });
-    useEventListener(anchorRef, 'focus', (e) => {
-        if (disableFocusListener)
-            return;
-        handleFocusVisible(e);
-        if (isFocusVisibleRef.current === true) {
-            handleOpen(e);
-        }
-    });
-    useEventListener(anchorRef, 'blur', (e) => {
-        handleBlurVisible(e);
-        if (isFocusVisibleRef.current === false) {
-            handleClose(e);
-        }
-    });
-    useEventListener(open ? document : null, 'keydown', (e) => {
-        if (e.key === 'Escape') {
-            handleClose(e);
-        }
-    });
-    const { nameOrDescProps, disabledOverrides } = computeTooltipA11y({
-        title,
-        describeChild,
-        triggerWhenDisabled,
-        open,
-        tooltipId,
-        child: children,
-    });
-    return (jsxs(Fragment, { children: [triggerWhenDisabled ? (jsx("span", { ...triggerWrapperProps, className: clsx('sui-tooltip-trigger-wrapper', triggerWrapperProps?.className), ref: handleAnchorRef, children: cloneElement(children, disabledOverrides) })) : (cloneElement(children, {
-                ref: handleAnchorRef,
-                ...nameOrDescProps,
-            })), renderTooltip(open, () => anchorRef.current, tooltipId)] }));
-};
-TooltipTrigger.displayName = 'SuiTooltipTrigger';
-
-const TooltipView = forwardRef((props, ref) => {
-    const { className, icon, size = 'small', classes, children, placement = 'bottom', PopperProps, color = 'neutral', anchorEl, motionProps, tooltipForceHide = false, disableInteractions = true, PopperPaperProps: popperPaperPropsProp, } = props;
-    const prefersReducedMotion = usePrefersReducedMotion();
-    const cls = useClasses('tooltip-view', 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);
-    return (jsx(Popper, { role: "tooltip", placement: placement, offset: 4, ...PopperProps, padding: popperPadding, className: cls('root', {
-            'force-hide': tooltipForceHide,
-            'disable-interactions': disableInteractions,
-        }), anchorEl: anchorEl, arrowHeight: 6, arrowPadding: 8, ref: ref, children: ({ arrowRef, arrowStyle }) => (jsxs(PopperPaper, { ...(motionProps ?? getFade({ prefersReducedMotion })), ...combineProps({
-                arrowRef,
-                arrowStyle,
-                classes: {
-                    root: cls('paper', color),
-                    content: cls('paper-content', `paper-content-${size}`),
-                },
-            }, popperPaperPropsProp), children: [icon && jsx(Icon, { symbol: icon, size: "small", className: cls('icon') }), jsx("div", { className: cls('content', `content-${size}`), children: children })] })) }));
-});
-TooltipView.displayName = 'SuiTooltipView';
-
-const Tooltip = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'Tooltip' });
-    const { children, open: openProp, delay, onOpenStateChange, title, disableFocusListener, disableBackdropAnimation, triggerWhenDisabled, triggerWrapperProps, PopperProps, describeChild = false, ...rest } = props;
-    const renderTooltip = (open, getAnchorEl, tooltipId) => {
-        const effectiveOpen = open && !(!title && title !== 0);
-        const content = effectiveOpen ? (jsx(TooltipView, { disableInteractions: openProp === undefined, ...rest, PopperProps: { ...PopperProps, id: tooltipId }, anchorEl: getAnchorEl, ref: ref, children: title })) : null;
-        return disableBackdropAnimation ? (jsx(Fragment, { children: content })) : (jsx(AnimatePresence, { children: content }));
-    };
-    return (jsx(TooltipTrigger, { disableFocusListener: disableFocusListener, open: openProp, delay: delay, onOpenStateChange: onOpenStateChange, renderTooltip: renderTooltip, triggerWhenDisabled: triggerWhenDisabled, triggerWrapperProps: triggerWrapperProps, tooltipId: PopperProps?.id, title: title, describeChild: describeChild, children: children }));
-});
-Tooltip.displayName = 'SuiTooltip';
-
-export { Tooltip as T, TooltipTrigger as a, TooltipView as b };

package/chunks/VirtualizedMenu.js

@@ -1,162 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { createContext, useContext, useRef, useLayoutEffect, forwardRef, useState, useMemo, useEffect } from 'react';
-import { useForkRef, combineProps, useClasses, useEventCallback } from '@ringcentral/spring-base';
-import { useThemeProps } from '@ringcentral/spring-theme';
-import clsx from 'clsx';
-import { u as useAnimationFrame } from './useAnimationFrame.js';
-import { P as Popover } from './Popover.js';
-import { VirtualizedList } from '../VirtualizedList.js';
-
-const VirtualizedMenuContext = createContext(null);
-const useVirtualizedMenuContext = () => useContext(VirtualizedMenuContext);
-
-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);
-        }
-    }, [virtualizedMenuContext?.open]);
-    return (jsx(VirtualizedList, { actions: handleListActions, ...rest, ListProps: combineProps({
-            role: 'menu',
-        }, rest.ListProps), ref: listRef, totalListHeightChanged: totalListHeightChangedProp, children: children }));
-};
-
-const MENU_VERTICAL_PADDING = 8;
-const VirtualizedMenu = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'VirtualizedMenu' });
-    const { classes, className, children, open, onClose, data, totalCount, isItemDisabled, actions, VirtualizedListProps, popperActions: popperActionsProp, initialFocus = true, maxHeight, PopperProps, ...rest } = props;
-    const popperPaperContentRef = useRef(null);
-    const paperContentContainerRef = useRef(null);
-    const hasItemsRenderedRef = useRef(false);
-    const [waitForHeightCompute, setWaitForHeightCompute] = useState(true);
-    const [menuHeight, setMenuHeight] = useState(MENU_VERTICAL_PADDING * 2);
-    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();
-    const menuContextValue = useMemo(() => {
-        return { open };
-    }, [open]);
-    const updateMenuHeight = useEventCallback(() => {
-        let computedMenuHeight = computedListHeight.current;
-        if (computedMenuHeight > availableHeight.current) {
-            computedMenuHeight = availableHeight.current;
-        }
-        if (maxHeight !== undefined && computedMenuHeight > maxHeight) {
-            computedMenuHeight = maxHeight;
-        }
-        setMenuHeight(computedMenuHeight);
-    });
-    const updatePopoverHeight = useEventCallback(() => {
-        if (paperContentContainerRef.current) {
-            paperContentContainerRef.current.style.height = `auto`;
-        }
-    });
-    const handleTotalListHeightChanged = useEventCallback((listHeight) => {
-        if (!hasItemsRenderedRef.current) {
-            return;
-        }
-        const adjustedHeight = listHeight + MENU_VERTICAL_PADDING * 2
-            ;
-        computedListHeight.current = adjustedHeight;
-        if (paperContentContainerRef.current) {
-            paperContentContainerRef.current.style.height = `${adjustedHeight}px`;
-        }
-        updateMenuHeight();
-        popperActions.current?.update();
-        if (waitForHeightCompute) {
-            requestAnimationFrame(() => {
-                setDeferPendingVirtualizedListActions(false);
-                requestAnimationFrame(() => {
-                    setWaitForHeightCompute(false);
-                });
-            });
-        }
-    });
-    const handleAvailableHeightChange = useEventCallback((value) => {
-        if (computedListHeight.current === -1 || !hasItemsRenderedRef.current) {
-            return;
-        }
-        availableHeight.current = value;
-        updateMenuHeight();
-        updatePopoverHeight();
-    });
-    useEffect(() => {
-        if (!open) {
-            hasItemsRenderedRef.current = false;
-        }
-        if (open) {
-            if (computedListHeight.current !== -1) {
-                updateMenuHeight();
-                setWaitForHeightCompute(false);
-                setDeferPendingVirtualizedListActions(false);
-                popperActions.current?.update();
-            }
-            else {
-                setMenuHeight(MENU_VERTICAL_PADDING * 2);
-                setWaitForHeightCompute(true);
-                setDeferPendingVirtualizedListActions(true);
-            }
-            if (popperPaperContentRef.current) {
-                popperPaperContentRef.current.style.maxHeight = 'none';
-            }
-        }
-    }, [open]);
-    return (jsx(Popover, { bordered: true, PopperProps: { ...PopperProps, padding: popperPadding }, ...rest, open: open, className: clsx(cls('root'), waitForHeightCompute && 'opacity-0'), PopperPaperProps: {
-            contentRef: popperPaperContentRef,
-        }, onClose: onClose, onAvailableHeightChange: handleAvailableHeightChange, ref: ref, motionProps: { variants: undefined }, actions: handlePopperActions, children: jsx("div", { className: cls('paper'), children: jsx("div", { ref: paperContentContainerRef, className: cls('paper-content-container'), children: jsx(VirtualizedMenuContext.Provider, { value: menuContextValue, children: 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 (totalCount === 0 ||
-                                    (totalCount === undefined &&
-                                        data !== undefined &&
-                                        data.length === 0) ||
-                                    (items && items.length > 0)) {
-                                    hasItemsRenderedRef.current = true;
-                                }
-                                VirtualizedListProps?.itemsRendered?.(items);
-                            },
-                            onKeyDown: (e) => {
-                                if (e.key === 'Tab') {
-                                    e.preventDefault();
-                                    onClose?.();
-                                }
-                            },
-                        }), children: children }) }) }) }) }));
-});
-VirtualizedMenu.displayName = 'SuiVirtualizedMenu';
-
-export { VirtualizedMenuContext as V, VirtualizedMenu as a, VirtualizedMenuList as b, useVirtualizedMenuContext as u };

package/chunks/VisuallyHidden.js

@@ -1,12 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { forwardRef } from 'react';
-import { useClasses } from '@ringcentral/spring-base';
-
-const VisuallyHidden = forwardRef((props, ref) => {
-    const { classes, className, children, ...rest } = props;
-    const cls = useClasses('visually-hidden', classes, className);
-    return (jsx("span", { className: cls('root'), ...rest, ref: ref, children: children }));
-});
-VisuallyHidden.displayName = 'SuiVisuallyHidden';
-
-export { VisuallyHidden as V };

package/chunks/composeEventHandlers.js

@@ -1,10 +0,0 @@
-const composeEventHandlers = (externalEventHandler, internalEventHandler, options = {}) => (event, ...args) => {
-    const { checkForDefaultPrevented = true } = options;
-    externalEventHandler?.(event, ...args);
-    if (checkForDefaultPrevented && event.defaultPrevented) {
-        return;
-    }
-    internalEventHandler?.(event, ...args);
-};
-
-export { composeEventHandlers as c };

package/chunks/getFade.js

@@ -1,27 +0,0 @@
-import { motionTransition } from '@ringcentral/spring-theme';
-
-const getFade = ({ toggle = true, prefersReducedMotion = false, toggleOnTransition, toggleOffTransition, } = {}) => ({
-    initial: 'hidden',
-    animate: toggle ? 'show' : 'hidden',
-    exit: 'hidden',
-    variants: {
-        show: {
-            opacity: 1,
-            transition: prefersReducedMotion
-                ? motionTransition.instant
-                : toggleOnTransition || motionTransition['haste-01-fast'],
-        },
-        hidden: {
-            opacity: 0,
-            transition: prefersReducedMotion
-                ? motionTransition.instant
-                : toggleOffTransition || motionTransition['haste-01-slow'],
-            pointerEvents: 'none',
-            transitionEnd: {
-                pointerEvents: undefined,
-            },
-        },
-    },
-});
-
-export { getFade as g };

package/chunks/getGrow.js

@@ -1,70 +0,0 @@
-import { motionTransition } from '@ringcentral/spring-theme';
-
-const getGrow = ({ toggle = true, direction = 'both', prefersReducedMotion = false, toggleOffTransition, toggleOnTransition, transformOrigin, } = {}) => {
-    const directionStr = direction === 'both' ? '' : direction.toUpperCase();
-    return {
-        style: {
-            transformOrigin: transformOriginToString(transformOrigin),
-        },
-        initial: 'invisible',
-        animate: toggle ? 'visible' : 'invisible',
-        exit: 'invisible',
-        variants: {
-            invisible: {
-                transform: `scale${directionStr}(0.618)`,
-                opacity: 0,
-                ...(!prefersReducedMotion &&
-                    toggleOffTransition && { transition: toggleOffTransition }),
-            },
-            visible: {
-                transform: `scale${directionStr}(1)`,
-                opacity: 1,
-                ...(!prefersReducedMotion &&
-                    toggleOnTransition && { transition: toggleOnTransition }),
-            },
-        },
-        transition: prefersReducedMotion
-            ? motionTransition.instant
-            : motionTransition['spring-01-fast'],
-    };
-};
-const transformOriginToString = (transformOrigin) => {
-    if (!transformOrigin)
-        return undefined;
-    return `${typeof transformOrigin.vertical === 'number'
-        ? transformOrigin.vertical + 'px'
-        : transformOrigin.vertical} ${typeof transformOrigin.horizontal === 'number'
-        ? transformOrigin.horizontal + 'px'
-        : transformOrigin.horizontal}`;
-};
-const alignmentToHorizontalTransformOrigin = {
-    start: 'left',
-    end: 'right',
-};
-const alignmentToVerticalTransformOrigin = {
-    start: 'top',
-    end: 'bottom',
-};
-const getTransformOriginStringForPlacement = (params) => {
-    const { placement } = params;
-    const [base, alignment] = placement.split('-');
-    if (base === 'top' || base === 'bottom') {
-        return transformOriginToString({
-            vertical: base === 'top' ? 'bottom' : 'top',
-            horizontal: !alignment
-                ? 'center'
-                : alignmentToHorizontalTransformOrigin[alignment],
-        });
-    }
-    else if (base === 'left' || base === 'right') {
-        return transformOriginToString({
-            vertical: !alignment
-                ? 'center'
-                : alignmentToVerticalTransformOrigin[alignment],
-            horizontal: base === 'left' ? 'right' : 'left',
-        });
-    }
-    return undefined;
-};
-
-export { getTransformOriginStringForPlacement as a, getGrow as g };

package/chunks/getSlideIn.js

@@ -1,30 +0,0 @@
-import { motionTransition } from '@ringcentral/spring-theme';
-
-const horizontal = ['right', 'left'];
-const plus = ['right', 'bottom'];
-const getSlideIn = ({ toggle = true, from = 'right', prefersReducedMotion = false, toggleOnTransition, toggleOffTransition, transition, } = {}) => {
-    const axis = horizontal.includes(from) ? 'x' : 'y';
-    const invisibleValue = plus.includes(from) ? '100%' : '-100%';
-    return {
-        initial: 'invisible',
-        animate: toggle ? 'visible' : 'invisible',
-        exit: 'invisible',
-        variants: {
-            visible: {
-                [axis]: 0,
-                ...(!prefersReducedMotion &&
-                    toggleOnTransition && { transition: toggleOnTransition }),
-            },
-            invisible: {
-                [axis]: invisibleValue,
-                ...(!prefersReducedMotion &&
-                    toggleOffTransition && { transition: toggleOffTransition }),
-            },
-        },
-        transition: prefersReducedMotion
-            ? motionTransition.instant
-            : (transition ?? motionTransition['spring-01-fast']),
-    };
-};
-
-export { getSlideIn as g };

package/chunks/hasContent.js

@@ -1,3 +0,0 @@
-const hasContent = (content) => Boolean(content) || content === 0;
-
-export { hasContent as h };

package/chunks/useAnimationFrame.js

@@ -1,15 +0,0 @@
-import { useMemo } from 'react';
-import { useWindowContext } from '@ringcentral/spring-base';
-
-function useAnimationFrame() {
-    const { externalWindow, globalThis: contextGlobal } = useWindowContext();
-    return useMemo(() => {
-        const contextWindow = externalWindow ?? contextGlobal;
-        return {
-            requestAnimationFrame: (callback) => contextWindow.requestAnimationFrame(callback),
-            cancelAnimationFrame: (handle) => contextWindow.cancelAnimationFrame(handle),
-        };
-    }, [externalWindow, contextGlobal]);
-}
-
-export { useAnimationFrame as u };

package/chunks/useFocusTrapStack.js

@@ -1,38 +0,0 @@
-import { useEffect } from 'react';
-import { useWindowContext, useId, useEventCallback } from '@ringcentral/spring-base';
-
-const FOCUS_TRAP_STACK = '__SUI_FOCUS_TRAP_STACK__';
-const getFocusTrapStack = (global) => {
-    if (!global[FOCUS_TRAP_STACK]) {
-        global[FOCUS_TRAP_STACK] = [];
-    }
-    return global[FOCUS_TRAP_STACK];
-};
-const useFocusTrapStack = ({ open, }) => {
-    const { globalThis } = useWindowContext();
-    const id = useId();
-    useEffect(() => {
-        if (open) {
-            const stack = getFocusTrapStack(globalThis);
-            if (stack.indexOf(id) < 0) {
-                stack.push(id);
-            }
-        }
-        return () => {
-            const stack = getFocusTrapStack(globalThis);
-            const index = stack.indexOf(id);
-            if (index >= 0) {
-                stack.splice(index, 1);
-            }
-        };
-    }, [open]);
-    const isEnabled = useEventCallback(() => {
-        const stack = getFocusTrapStack(globalThis);
-        return stack.at(-1) === id;
-    });
-    return {
-        isEnabled,
-    };
-};
-
-export { useFocusTrapStack as u };

package/chunks/useHelperTextId.js

@@ -1,24 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { forwardRef } from 'react';
-import clsx from 'clsx';
-import { useClasses } from '@ringcentral/spring-base';
-import { useThemeProps } from '@ringcentral/spring-theme';
-import { h as hasContent } from './hasContent.js';
-import '@mui/utils';
-
-const FormField = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'FormField' });
-    const { classes, className, children, htmlFor, label, labelProps, helperText, required, disabled, error, variant = 'standard', size = 'xlarge', contentRef, contentProps, focused, FormHelperTextProps, ...rest } = props;
-    const cls = useClasses('form-field', classes, className);
-    return (jsxs("div", { ...rest, ref: ref, className: cls('root', variant, { disabled, error, focused }), "aria-disabled": disabled, children: [hasContent(label) && (jsxs("label", { htmlFor: htmlFor, ...labelProps, className: clsx(cls('label', `${variant}-label`, error && 'error-label'), labelProps?.className), children: [label, required ? ' *' : ''] })), jsxs("div", { className: cls('container', error && 'error-container'), children: [jsx("div", { className: cls('content', size, `${size}-content`, `${variant}-${size}`, `${variant}-content`, error && 'error-content', error && `error-${variant}-content`), ref: contentRef, ...contentProps, children: children }), jsx("div", { className: cls('focus-effect', `${variant}-focus-effect`, error && 'error-focus-effect') })] }), hasContent(helperText) && (jsx("div", { ...FormHelperTextProps, className: clsx(cls('helper-text', error && 'error-helper-text'), FormHelperTextProps?.className), children: helperText }))] }));
-});
-FormField.displayName = 'SuiFormField';
-
-const useHelperTextId = ({ helperText, id, FormHelperTextProps, }) => {
-    if (!hasContent(helperText)) {
-        return undefined;
-    }
-    return FormHelperTextProps?.id || `${id}-helper-text`;
-};
-
-export { FormField as F, useHelperTextId as u };