@ringcentral/spring-ui 1.12.0 → 1.13.0

package/chunks/useListNavigation.js

@@ -1,199 +0,0 @@
-import { jsxs, jsx } from 'react/jsx-runtime';
-import { useEventCallback } from '@ringcentral/spring-base';
-import { createContext, useContext, useRef, useMemo, useImperativeHandle } from 'react';
-
-const ListNavigationContext = createContext(null);
-const useListNavigationContext = () => useContext(ListNavigationContext);
-
-const useListNavigation = (props) => {
-    const { preventContainerScroll = true, searchAndFocusItemHandler: searchAndFocusItemHandlerProp = defaultSearchAndFocusItem, actions, } = props;
-    const currentFocusedItemRef = useRef(null);
-    const listRef = useRef(null);
-    const sentinelArrowNavRef = useRef(null);
-    const sentinelTabBoundaryRef = useRef(null);
-    const skipEnforceFocusRef = useRef(false);
-    const focusList = () => {
-        skipEnforceFocusRef.current = true;
-        listRef.current.focus();
-    };
-    const focusTabBoundary = () => {
-        skipEnforceFocusRef.current = true;
-        sentinelTabBoundaryRef.current.focus();
-    };
-    const itemActions = useMemo(() => ({
-        onTab: () => {
-            skipEnforceFocusRef.current = true;
-            sentinelTabBoundaryRef.current.focus();
-        },
-        onShiftTab: () => {
-            skipEnforceFocusRef.current = true;
-            listRef.current.focus();
-        },
-        updateFocusedItem: (el) => {
-            currentFocusedItemRef.current = el;
-        },
-    }), []);
-    const focusFirstItem = useEventCallback(() => {
-        const { focused } = searchAndFocusItemHandler('first');
-        if (!focused) {
-            focusList();
-        }
-    });
-    useImperativeHandle(actions, () => ({
-        focus: focusFirstItem,
-    }), []);
-    const sentinelFocusHandler = (e) => {
-        if (e.target === e.currentTarget) {
-            const skipEnforceFocus = skipEnforceFocusRef.current;
-            if (skipEnforceFocus) {
-                skipEnforceFocusRef.current = false;
-                return;
-            }
-            focusFirstItem();
-        }
-    };
-    const searchAndFocusItemHandler = (searchElementOption) => {
-        return searchAndFocusItemHandlerProp(searchElementOption, {
-            sentinelEnd: sentinelArrowNavRef.current,
-            list: listRef.current,
-        });
-    };
-    const listKeyDownHandler = (e) => {
-        const focusedItem = currentFocusedItemRef.current;
-        const key = e.key;
-        if (focusedItem) {
-            const searchElementOption = {
-                ArrowDown: {
-                    baseElement: focusedItem,
-                    direction: 'down',
-                },
-                ArrowUp: {
-                    baseElement: focusedItem,
-                    direction: 'up',
-                },
-                Home: 'first',
-                End: 'last',
-            }[key];
-            if (searchElementOption) {
-                const { focused, isAfterBaseElement } = searchAndFocusItemHandler(searchElementOption);
-                if (!focused) {
-                    focusList();
-                }
-                if (!isAfterBaseElement || preventContainerScroll) {
-                    e.preventDefault();
-                }
-            }
-        }
-        else {
-            if (e.target === e.currentTarget && key === 'Tab' && !e.shiftKey) {
-                focusTabBoundary();
-            }
-        }
-    };
-    const getListProps = (otherHandler) => {
-        const { onKeyDown, onFocus } = otherHandler;
-        const handleKeyDown = (e) => {
-            onKeyDown?.(e);
-            if (e.defaultPrevented) {
-                return;
-            }
-            listKeyDownHandler(e);
-        };
-        const handleFocus = (e) => {
-            sentinelFocusHandler(e);
-            onFocus?.(e);
-        };
-        return {
-            tabIndex: 0,
-            onKeyDown: handleKeyDown,
-            onFocus: handleFocus,
-        };
-    };
-    const renderItems = (items) => {
-        return (jsxs(ListNavigationContext.Provider, { value: itemActions, children: [items, jsx("div", { "aria-hidden": "true", ref: sentinelArrowNavRef })] }));
-    };
-    const renderTabBoundary = () => {
-        return (jsx("div", { style: { position: 'fixed', bottom: '50%' }, ref: sentinelTabBoundaryRef, tabIndex: 0, onFocus: sentinelFocusHandler }));
-    };
-    return { renderItems, renderTabBoundary, getListProps, listRef };
-};
-const isUnfocusable = (el) => el.matches('.sui-disabled, :disabled, hr, [role="separator"], [disabled]');
-const defaultSearchAndFocusItem = (searchElementOption, helperElements) => {
-    const { list, sentinelEnd } = helperElements;
-    if (list.firstElementChild === sentinelEnd) {
-        return { focused: false };
-    }
-    const getFirstItem = () => {
-        const firstItem = list.firstElementChild;
-        if (firstItem === sentinelEnd) {
-            throw Error('SPRING [useListNavigation]: must have child element');
-        }
-        return firstItem;
-    };
-    const getLastItem = () => {
-        const lastItem = sentinelEnd.previousElementSibling;
-        if (!lastItem) {
-            throw Error('SPRING [useListNavigation]: must have child element');
-        }
-        return lastItem;
-    };
-    let direction;
-    let startElement;
-    if (typeof searchElementOption === 'string') {
-        if (searchElementOption === 'first') {
-            startElement = getFirstItem();
-            direction = 'down';
-        }
-        else {
-            startElement = getLastItem();
-            direction = 'up';
-        }
-        if (!isUnfocusable(startElement)) {
-            startElement.focus();
-            return { focused: true };
-        }
-    }
-    else {
-        startElement = searchElementOption.baseElement;
-        direction = searchElementOption.direction;
-    }
-    let pointer = startElement;
-    let isAfterBaseElement = true;
-    if (direction === 'up') {
-        do {
-            if (!pointer.previousElementSibling) {
-                pointer = getLastItem();
-                isAfterBaseElement = false;
-            }
-            else {
-                pointer = pointer.previousElementSibling;
-            }
-            if (!isUnfocusable(pointer)) {
-                break;
-            }
-        } while (pointer !== startElement);
-    }
-    else {
-        do {
-            if (pointer.nextElementSibling === sentinelEnd) {
-                pointer = getFirstItem();
-                isAfterBaseElement = false;
-            }
-            else {
-                pointer = pointer.nextElementSibling;
-            }
-            if (!isUnfocusable(pointer)) {
-                break;
-            }
-        } while (pointer !== startElement);
-    }
-    if (isUnfocusable(pointer)) {
-        return { focused: false };
-    }
-    pointer.focus();
-    return typeof searchElementOption === 'string'
-        ? { focused: true }
-        : { focused: true, isAfterBaseElement };
-};
-
-export { ListNavigationContext as L, useListNavigation as a, useListNavigationContext as u };

package/chunks/useMenuItemSelect.js

@@ -1,282 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { createContext, useContext, forwardRef, useRef, useLayoutEffect, useCallback, useMemo } from 'react';
-import { useFocusVisible, useActive, useForkRef, combineProps, useId, useHover, useEventCallback } from '@ringcentral/spring-base';
-import { CheckBoldMd } from '@ringcentral/spring-icon';
-import { useThemeProps, useClassesWithMode } from '@ringcentral/spring-theme';
-import { I as Icon } from './Icon.js';
-import { u as useAnimationFrame } from './useAnimationFrame.js';
-import './useNestedParentMenu.js';
-import { u as useNestedMenuItem } from './useNestedMenuItem.js';
-import { useVirtualizedItemPropsContext } from '../VirtualizedList.js';
-import { c as composeEventHandlers } from './composeEventHandlers.js';
-import { unstable_setRef } from '@mui/utils';
-import { useItemNavigation } from '../ListNavigation.js';
-import { u as useMenuContext } from './Menu.js';
-
-const MenuListContext = createContext({
-    nowrap: true,
-});
-const useMenuListContext = () => useContext(MenuListContext);
-
-const SubMenuTriggerNestedIdContext = createContext(null);
-
-const MenuItemSelectContext = createContext(null);
-const useMenuItemSelectContext = () => useContext(MenuItemSelectContext);
-
-const useMenuItem = (props) => {
-    const { onBlur, onFocus, onKeyDown, onKeyUp, onClick, ref, disabled, autoClose, } = props;
-    const { keyboardNavHandlers, itemRef } = useItemNavigation() ?? {};
-    const { focusVisible, focusVisibleRef, focusVisibleHandlers } = useFocusVisible({
-        onFocus: (e) => {
-            keyboardNavHandlers?.onFocus(e);
-            onFocus?.(e);
-        },
-        onBlur: (e) => {
-            keyboardNavHandlers?.onBlur(e);
-            onBlur?.(e);
-        },
-    });
-    const { close: closeMenu } = useMenuContext() ?? {};
-    const handleClick = disabled
-        ? undefined
-        : composeEventHandlers(onClick, () => {
-            if (autoClose)
-                closeMenu?.();
-        });
-    const { active, activeHandlers } = useActive({
-        disabled,
-        onKeyDown: (e) => {
-            onKeyDown?.(e);
-            keyboardNavHandlers?.onKeyDown(e);
-        },
-        onKeyUp,
-        onClick: handleClick,
-    });
-    const handleItemRef = useForkRef(ref, focusVisibleRef, itemRef);
-    const getRootProps = (otherProps = {}) => {
-        const { ref: otherRef, ...restOtherProps } = otherProps;
-        return {
-            role: 'menuitem',
-            tabIndex: '-1',
-            ...(disabled ? { 'aria-disabled': true } : null),
-            ...combineProps(restOtherProps, {
-                ...focusVisibleHandlers,
-                ...activeHandlers,
-            }),
-            ref: (instance) => {
-                unstable_setRef(otherRef, instance);
-                unstable_setRef(handleItemRef, instance);
-            },
-        };
-    };
-    return { getRootProps, focusVisible, active };
-};
-
-const useVirtualizedMenuItem = (props) => {
-    const { onBlur, onFocus, onKeyDown, onKeyUp, onClick, disabled, autoClose, ref, } = props;
-    const { keyboardNavHandlers, itemRef } = useItemNavigation() ?? {};
-    const vlItemProps = useVirtualizedItemPropsContext();
-    const { focusVisible, focusVisibleRef, focusVisibleHandlers } = useFocusVisible({
-        onFocus: (e) => {
-            keyboardNavHandlers?.onFocus(e);
-            onFocus?.(e);
-        },
-        onBlur: (e) => {
-            keyboardNavHandlers?.onBlur(e);
-            onBlur?.(e);
-        },
-    });
-    const { close: closeMenu } = useMenuContext() ?? {};
-    const handleClick = disabled
-        ? undefined
-        : composeEventHandlers(onClick, () => {
-            if (autoClose)
-                closeMenu?.();
-        });
-    const { active, activeHandlers } = useActive({
-        disabled,
-        onKeyDown: (e) => {
-            onKeyDown?.(e);
-            keyboardNavHandlers?.onKeyDown(e);
-        },
-        onKeyUp,
-        onClick: handleClick,
-    });
-    const handleItemRef = useForkRef(ref, focusVisibleRef, itemRef);
-    const getRootProps = (otherProps = {}) => {
-        const { ref: otherRef, ...restOtherProps } = otherProps;
-        return {
-            role: 'menuitem',
-            tabIndex: -1,
-            ...(disabled ? { 'aria-disabled': true } : null),
-            ...combineProps(restOtherProps, {
-                ...focusVisibleHandlers,
-                ...activeHandlers,
-                ...vlItemProps,
-            }),
-            ref: (instance) => {
-                unstable_setRef(otherRef, instance);
-                unstable_setRef(handleItemRef, instance);
-            },
-        };
-    };
-    return { getRootProps, focusVisible, active };
-};
-
-const MenuItem = forwardRef((inProps, ref) => {
-    const props = useThemeProps({ props: inProps, name: 'MenuItem' });
-    const { classes, className, children, selected, disabled, onMouseEnter, onMouseLeave, onPointerMove, onBlur, onFocus, onKeyDown, onKeyUp, onClick, highlighted = false, focused = false, autoClose = true, autoFocus, ...rest } = props;
-    const cls = useClassesWithMode('menu-item', classes, className);
-    const vlItemProps = useVirtualizedItemPropsContext();
-    const isInVlRef = useRef(Boolean(vlItemProps));
-    const { requestAnimationFrame } = useAnimationFrame();
-    const useMenuItemHook = (() => {
-        if (isInVlRef.current) {
-            return useVirtualizedMenuItem;
-        }
-        else {
-            return useMenuItem;
-        }
-    })();
-    const itemRef = useRef(null);
-    const handleRef = useForkRef(itemRef, ref);
-    const { getRootProps, focusVisible, active } = useMenuItemHook({
-        autoClose,
-        disabled,
-        onBlur,
-        onClick,
-        onFocus,
-        onKeyDown,
-        onKeyUp,
-        ref: handleRef,
-    });
-    const selectable = !(selected === undefined);
-    const selectContextValue = useMenuItemSelectContext();
-    const menuListContextValue = useMenuListContext();
-    const selectMode = selectContextValue
-        ? selectContextValue.selectMode
-        : 'single';
-    const subMenuTriggerNestedId = useContext(SubMenuTriggerNestedIdContext);
-    const generatedId = useId();
-    const id = subMenuTriggerNestedId ?? generatedId;
-    const isSubMenuTrigger = Boolean(subMenuTriggerNestedId);
-    const { requestItemHover } = useNestedMenuItem({ id });
-    const { hoverHandlers } = useHover({
-        onMouseEnter,
-        onMouseLeave,
-    });
-    const handlePointerMove = (event) => {
-        if (event.pointerType === 'mouse' &&
-            !requestItemHover(event, {
-                closeOpenedSubMenu: !isSubMenuTrigger,
-            })) {
-            event.preventDefault();
-        }
-        onPointerMove?.(event);
-    };
-    useLayoutEffect(() => {
-        if (autoFocus) {
-            itemRef.current?.focus();
-            requestAnimationFrame(() => {
-                if (process.env.NODE_ENV === 'test' &&
-                    typeof itemRef.current?.scrollIntoView !== 'function') {
-                    return;
-                }
-                itemRef.current?.scrollIntoView({
-                    block: 'nearest',
-                    inline: 'nearest',
-                });
-            });
-        }
-    }, [autoFocus, requestAnimationFrame]);
-    return (jsx("div", { className: cls('root', {
-            selectable,
-            selected,
-            focusVisible,
-            disabled,
-            active,
-            highlighted,
-            focused,
-            nowrap: menuListContextValue.nowrap,
-        }), ...getRootProps(rest), ...hoverHandlers, onPointerMove: handlePointerMove, children: jsxs("div", { className: cls('container'), children: [selectable && (jsx("div", { className: cls('select-indicator'), children: selectMode === 'single' ? (jsx("span", { className: cls('select-dot') })) : (jsx(Icon, { symbol: CheckBoldMd, size: "small" })) })), children] }) }));
-});
-MenuItem.displayName = 'SuiMenuItem';
-
-var Action;
-(function (Action) {
-    Action["SELECT"] = "select";
-    Action["DESELECT"] = "deselect";
-})(Action || (Action = {}));
-const useMenuItemSelect = (props) => {
-    const { widget = 'menu', selectMode = 'single', value: valueProp = selectMode === 'single' ? null : [], onChange, onClose, autoFocus: autoFocusProp = true, } = props;
-    const isSingleMode = selectMode === 'single';
-    if (process.env.NODE_ENV !== 'production' &&
-        !isSingleMode &&
-        !Array.isArray(valueProp)) {
-        throw Error('SPRING [useMenuItemSelect]: value must be an array if selectMode is multiple');
-    }
-    const value = valueProp;
-    const getMenuItemProps = useCallback((itemValue) => {
-        let selected;
-        let autoFocus;
-        if (isSingleMode) {
-            selected = value === itemValue;
-            autoFocus = selected;
-        }
-        else {
-            selected = value.includes(itemValue);
-            autoFocus = value[0] === itemValue;
-        }
-        const menuItemRole = selectMode === 'single' ? 'menuitemradio' : 'menuitemcheckbox';
-        const ariaProps = widget === 'menu'
-            ? { 'aria-checked': selected }
-            : { 'aria-selected': selected };
-        return {
-            role: widget === 'menu' ? menuItemRole : 'option',
-            ...ariaProps,
-            selected,
-            autoFocus: autoFocusProp && autoFocus,
-        };
-    }, [isSingleMode, selectMode, widget, autoFocusProp, value]);
-    const handleSelect = useEventCallback((itemValue) => {
-        let action = Action.SELECT;
-        if (isSingleMode) {
-            if (value === itemValue) {
-                onClose?.();
-            }
-            else {
-                onChange?.(itemValue);
-            }
-        }
-        else {
-            const index = value.indexOf(itemValue);
-            let newValue;
-            if (index >= 0) {
-                action = Action.DESELECT;
-                newValue = [
-                    ...value.slice(0, index),
-                    ...value.slice(index + 1),
-                ];
-            }
-            else {
-                newValue = [...value, itemValue];
-            }
-            onChange?.(newValue, {
-                value: itemValue,
-                action,
-            });
-        }
-    });
-    const contextValue = useMemo(() => ({
-        selectMode,
-        value,
-        handleSelect,
-        getMenuItemProps,
-    }), [getMenuItemProps, handleSelect, selectMode, value]);
-    return {
-        value,
-        contextValue,
-    };
-};
-
-export { Action as A, MenuItem as M, SubMenuTriggerNestedIdContext as S, MenuItemSelectContext as a, useMenuItem as b, useMenuItemSelect as c, useVirtualizedMenuItem as d, MenuListContext as e, useMenuListContext as f, useMenuItemSelectContext as u };

package/chunks/useMotionSafeTransition.js

@@ -1,9 +0,0 @@
-import { motionTransition } from '@ringcentral/spring-theme';
-import { u as usePrefersReducedMotion } from './usePrefersReducedMotion.js';
-
-const useMotionSafeTransition = (transition) => {
-    const prefersReducedMotion = usePrefersReducedMotion();
-    return prefersReducedMotion ? motionTransition.instant : transition;
-};
-
-export { useMotionSafeTransition as u };

package/chunks/useNestedMenuItem.js

@@ -1,27 +0,0 @@
-import { useCallback, useEffect } from 'react';
-import { u as useNestedMenuContext } from './useNestedParentMenu.js';
-
-const useNestedMenuItem = (props) => {
-    const context = useNestedMenuContext();
-    const { hovered, id } = props;
-    const { isPointerMovingToSubMenu: isPointerMovingToSubMenuContext, onPointerGraceIntentChange, registHoveredItem, } = context ?? {};
-    const requestItemHover = useCallback((event, options) => {
-        const canApplyHover = registHoveredItem?.(id, event, options);
-        return canApplyHover ?? true;
-    }, [id, registHoveredItem]);
-    useEffect(() => {
-        if (hovered) {
-            requestItemHover();
-        }
-    }, [hovered, requestItemHover]);
-    const isPointerMovingToSubMenu = useCallback((event, intent) => {
-        return isPointerMovingToSubMenuContext?.(event, intent) ?? false;
-    }, [isPointerMovingToSubMenuContext]);
-    return {
-        isPointerMovingToSubMenu,
-        onPointerGraceIntentChange,
-        requestItemHover,
-    };
-};
-
-export { useNestedMenuItem as u };

package/chunks/useNestedParentMenu.js

@@ -1,113 +0,0 @@
-import { createContext, useContext, useRef, useCallback, useMemo, useLayoutEffect } from 'react';
-
-const NestedMenuContext = createContext(null);
-const useNestedMenuContext = () => {
-    return useContext(NestedMenuContext);
-};
-
-const getPointFromPointerEvent = (event) => ({
-    x: event.clientX,
-    y: event.clientY,
-});
-const isPointInPolygon = (point, polygon) => {
-    let inside = false;
-    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-        const pointI = polygon[i];
-        const pointJ = polygon[j];
-        const intersects = pointI.y > point.y !== pointJ.y > point.y &&
-            point.x <
-                ((pointJ.x - pointI.x) * (point.y - pointI.y)) / (pointJ.y - pointI.y) +
-                    pointI.x;
-        if (intersects) {
-            inside = !inside;
-        }
-    }
-    return inside;
-};
-const isPointerInGraceArea = (event, area) => {
-    if (!area)
-        return false;
-    return isPointInPolygon(getPointFromPointerEvent(event), area);
-};
-
-const useNestedParentMenu = (props) => {
-    const openedSubMenuSymbolRef = useRef(null);
-    const pointerGraceIntentRef = useRef(null);
-    const pointerDirRef = useRef('right');
-    const lastPointerXRef = useRef(0);
-    const { open } = props;
-    const onPointerGraceIntentChange = useCallback((intent) => {
-        pointerGraceIntentRef.current = intent;
-    }, []);
-    const isPointerMovingToSubMenu = useCallback((event, intentArg) => {
-        const intent = intentArg === undefined ? pointerGraceIntentRef.current : intentArg;
-        const isMovingTowards = pointerDirRef.current === intent?.side;
-        return isMovingTowards && isPointerInGraceArea(event, intent?.area);
-    }, []);
-    const onContentPointerMove = useCallback((event) => {
-        const pointerXHasChanged = lastPointerXRef.current !== event.clientX;
-        if (pointerXHasChanged) {
-            pointerDirRef.current =
-                event.clientX > lastPointerXRef.current ? 'right' : 'left';
-            lastPointerXRef.current = event.clientX;
-        }
-    }, []);
-    const onContentClickCapture = useCallback((event) => {
-        const target = event.target;
-        const openedSubMenu = openedSubMenuSymbolRef.current;
-        if (!target || !event.currentTarget.contains(target)) {
-            return;
-        }
-        if (openedSubMenu?.getAnchorElement?.()?.contains(target)) {
-            return;
-        }
-        openedSubMenu?.closeSubMenu();
-    }, []);
-    const contextValue = useMemo(() => {
-        return {
-            registHoveredItem: (id, event, options) => {
-                const symbol = openedSubMenuSymbolRef.current;
-                if (!symbol || id === symbol.anchorId) {
-                    return true;
-                }
-                if (event && isPointerMovingToSubMenu(event)) {
-                    return false;
-                }
-                if (options?.closeOpenedSubMenu ?? true) {
-                    symbol.closeSubMenu();
-                }
-                return true;
-            },
-            registOpenedSubMenu: (menuItemSymbol) => {
-                openedSubMenuSymbolRef.current?.closeSubMenu();
-                openedSubMenuSymbolRef.current = menuItemSymbol;
-                return () => {
-                    if (openedSubMenuSymbolRef.current === menuItemSymbol) {
-                        openedSubMenuSymbolRef.current = null;
-                    }
-                };
-            },
-            isPointerMovingToSubMenu,
-            onPointerGraceIntentChange,
-        };
-    }, [isPointerMovingToSubMenu, onPointerGraceIntentChange]);
-    useLayoutEffect(() => {
-        if (!open) {
-            openedSubMenuSymbolRef.current?.closeSubMenu();
-            openedSubMenuSymbolRef.current = null;
-            onPointerGraceIntentChange(null);
-        }
-    }, [onPointerGraceIntentChange, open]);
-    return {
-        contentClickHandlers: {
-            onClickCapture: onContentClickCapture,
-        },
-        contentPointerHandlers: {
-            onPointerMove: onContentPointerMove,
-        },
-        contextValue,
-        getHaveOpenedSubMenu: () => Boolean(openedSubMenuSymbolRef.current),
-    };
-};
-
-export { NestedMenuContext as N, useNestedParentMenu as a, useNestedMenuContext as u };

package/chunks/usePrefersReducedMotion.js

@@ -1,36 +0,0 @@
-import { useGlobalListener } from '@ringcentral/spring-base';
-import { MotionConfigContext } from 'framer-motion';
-import { useState, useContext } from 'react';
-
-let instance;
-const getPrefersReducedMotionMediaQuery = () => {
-    if (!instance ||
-        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',
-    });
-    if (context.reducedMotion === 'user') {
-        return shouldReduceMotion;
-    }
-    if (context.reducedMotion === 'always' ||
-        process.env.NODE_ENV === 'test') {
-        return true;
-    }
-    if (context.reducedMotion === 'never') {
-        return false;
-    }
-    return shouldReduceMotion;
-};
-
-export { usePrefersReducedMotion as u };

package/chunks/useTooltipForceHide.js

@@ -1,27 +0,0 @@
-import { useState, useRef, useCallback, useEffect } from 'react';
-
-const useTooltipForceHide = (forceHide) => {
-    const [open, setOpen] = useState(false);
-    const openStateStore = useRef();
-    const onOpenStateChange = useCallback((event, isOpen) => {
-        if (openStateStore.current !== undefined) {
-            openStateStore.current = isOpen;
-        }
-        else {
-            setOpen(isOpen);
-        }
-    }, []);
-    useEffect(() => {
-        if (open && forceHide) {
-            setOpen(false);
-            openStateStore.current = open;
-        }
-        if (!forceHide && openStateStore.current !== undefined) {
-            setOpen(openStateStore.current);
-            openStateStore.current = undefined;
-        }
-    }, [open, forceHide]);
-    return { open, onOpenStateChange };
-};
-
-export { useTooltipForceHide as u };