@wix/site-ui 1.30.0 → 1.31.0

package/dist/Tooltip/index.js

@@ -1,7 +1,958 @@
-import { jsx } from "react/jsx-runtime";
-import { Tooltip } from "@base-ui/react/tooltip";
+import { jsx, jsxs } from "react/jsx-runtime";
 import clsx from "clsx";
+import { mergeProps, useRenderElement, esm_formatErrorMessage } from "../8272.js";
+import { Timeout, useTimeout } from "../42.js";
+import { useIsoLayoutEffect } from "../6499.js";
+import { useHoverFloatingInteraction, useHoverInteractionSharedState, getDelay } from "../3056.js";
+import { createChangeEventDetails } from "../4768.js";
+import { POPUP_COLLISION_AVOIDANCE, triggerOpenStateMapping, popupStateMapping, popupStateMapping_CommonTriggerDataAttributes } from "../4388.js";
+import { getWindow, isElement } from "../3829.js";
+import { useDismiss, PopupTriggerMap, createSelector, fastComponent, fastComponentRef, ReactStore } from "../5992.js";
+import { useBaseUiId } from "../6046.js";
+import { useTriggerDataForwarding, usePopupInteractionProps, setOpenTriggerState, usePopupStore, useImplicitActiveTrigger, useOnFirstRender, useOpenStateTransitions, FOCUSABLE_POPUP_PROPS } from "../8106.js";
+import { useValueAsRef } from "../4707.js";
+import { getTarget, contains } from "../4549.js";
+import { safePolygon, useHoverReferenceInteraction } from "../3670.js";
+import { useFocus } from "../904.js";
+import { imperativeAction, triggerFocus, escapeKey, disabled as reason_parts_disabled, triggerHover, triggerPress } from "../2418.js";
+import { isMouseLikePointerType } from "../6330.js";
+import { usePositioner, adaptiveOriginMiddleware_adaptiveOrigin, useAnchorPositioning, getDisabledMountTransitionStyles } from "../8750.js";
+import { transitionStatusMapping, useOpenChangeComplete } from "../880.js";
+import { usePopupViewport } from "../8171.js";
+import { useStableCallback } from "../7541.js";
+import { addEventListener } from "../4723.js";
+import { createPopupFloatingRootContext, popupStoreSelectors, createInitialPopupStoreState } from "../6535.js";
+import { FloatingPortalLite_FloatingPortalLite } from "../8960.js";
 import * as __rspack_external_react from "react";
+import * as __rspack_external_react_dom_7136dc57 from "react-dom";
+const TooltipRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) TooltipRootContext.displayName = "TooltipRootContext";
+function useTooltipRootContext(optional) {
+    const context = __rspack_external_react.useContext(TooltipRootContext);
+    if (void 0 === context && !optional) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>.' : esm_formatErrorMessage(72));
+    return context;
+}
+const TooltipProviderContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) TooltipProviderContext.displayName = "TooltipProviderContext";
+function useTooltipProviderContext() {
+    return __rspack_external_react.useContext(TooltipProviderContext);
+}
+const FloatingDelayGroupContext = /*#__PURE__*/ __rspack_external_react.createContext({
+    hasProvider: false,
+    timeoutMs: 0,
+    delayRef: {
+        current: 0
+    },
+    initialDelayRef: {
+        current: 0
+    },
+    timeout: new Timeout(),
+    currentIdRef: {
+        current: null
+    },
+    currentContextRef: {
+        current: null
+    }
+});
+if ("production" !== process.env.NODE_ENV) FloatingDelayGroupContext.displayName = "FloatingDelayGroupContext";
+function FloatingDelayGroup(props) {
+    const { children, delay, timeoutMs = 0 } = props;
+    const delayRef = __rspack_external_react.useRef(delay);
+    const initialDelayRef = __rspack_external_react.useRef(delay);
+    const currentIdRef = __rspack_external_react.useRef(null);
+    const currentContextRef = __rspack_external_react.useRef(null);
+    const timeout = useTimeout();
+    return /*#__PURE__*/ jsx(FloatingDelayGroupContext.Provider, {
+        value: __rspack_external_react.useMemo(()=>({
+                hasProvider: true,
+                delayRef,
+                initialDelayRef,
+                currentIdRef,
+                timeoutMs,
+                currentContextRef,
+                timeout
+            }), [
+            timeoutMs,
+            timeout
+        ]),
+        children: children
+    });
+}
+function useDelayGroup(context, options = {
+    open: false
+}) {
+    const { open } = options;
+    const store = 'rootStore' in context ? context.rootStore : context;
+    const floatingId = store.useState('floatingId');
+    const groupContext = __rspack_external_react.useContext(FloatingDelayGroupContext);
+    const { currentIdRef, delayRef, timeoutMs, initialDelayRef, currentContextRef, hasProvider, timeout } = groupContext;
+    const [isInstantPhase, setIsInstantPhase] = __rspack_external_react.useState(false);
+    useIsoLayoutEffect(()=>{
+        function unset() {
+            setIsInstantPhase(false);
+            currentContextRef.current?.setIsInstantPhase(false);
+            currentIdRef.current = null;
+            currentContextRef.current = null;
+            delayRef.current = initialDelayRef.current;
+        }
+        if (!currentIdRef.current) return;
+        if (!open && currentIdRef.current === floatingId) {
+            setIsInstantPhase(false);
+            if (timeoutMs) {
+                const closingId = floatingId;
+                timeout.start(timeoutMs, ()=>{
+                    if (store.select('open') || currentIdRef.current && currentIdRef.current !== closingId) return;
+                    unset();
+                });
+                return ()=>{
+                    timeout.clear();
+                };
+            }
+            unset();
+        }
+    }, [
+        open,
+        floatingId,
+        currentIdRef,
+        delayRef,
+        timeoutMs,
+        initialDelayRef,
+        currentContextRef,
+        timeout,
+        store
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (!open) return;
+        const prevContext = currentContextRef.current;
+        const prevId = currentIdRef.current;
+        timeout.clear();
+        currentContextRef.current = {
+            onOpenChange: store.setOpen,
+            setIsInstantPhase
+        };
+        currentIdRef.current = floatingId;
+        delayRef.current = {
+            open: 0,
+            close: getDelay(initialDelayRef.current, 'close')
+        };
+        if (null !== prevId && prevId !== floatingId) {
+            setIsInstantPhase(true);
+            prevContext?.setIsInstantPhase(true);
+            prevContext?.onOpenChange(false, createChangeEventDetails("none"));
+        } else {
+            setIsInstantPhase(false);
+            prevContext?.setIsInstantPhase(false);
+        }
+    }, [
+        open,
+        floatingId,
+        store,
+        currentIdRef,
+        delayRef,
+        initialDelayRef,
+        currentContextRef,
+        timeout
+    ]);
+    useIsoLayoutEffect(()=>()=>{
+            currentContextRef.current = null;
+        }, [
+        currentContextRef
+    ]);
+    return __rspack_external_react.useMemo(()=>({
+            hasProvider,
+            delayRef,
+            isInstantPhase
+        }), [
+        hasProvider,
+        delayRef,
+        isInstantPhase
+    ]);
+}
+let TooltipTriggerDataAttributes_TooltipTriggerDataAttributes = function(TooltipTriggerDataAttributes) {
+    TooltipTriggerDataAttributes[TooltipTriggerDataAttributes["popupOpen"] = popupStateMapping_CommonTriggerDataAttributes.popupOpen] = "popupOpen";
+    TooltipTriggerDataAttributes["triggerDisabled"] = "data-trigger-disabled";
+    return TooltipTriggerDataAttributes;
+}({});
+const TOOLTIP_TRIGGER_IDENTIFIER = 'data-base-ui-tooltip-trigger';
+function getTargetElement(event) {
+    if ('composedPath' in event) {
+        const path = event.composedPath();
+        for(let i = 0; i < path.length; i += 1){
+            const element = path[i];
+            if (isElement(element)) return element;
+        }
+    }
+    const target = event.target;
+    if (isElement(target)) return target;
+    return null;
+}
+function closestEnabledTooltipTrigger(element) {
+    let current = element;
+    while(current){
+        if (current.hasAttribute(TOOLTIP_TRIGGER_IDENTIFIER)) return current;
+        const parentElement = current.parentElement;
+        if (parentElement) {
+            current = parentElement;
+            continue;
+        }
+        const root = current.getRootNode();
+        current = 'host' in root && isElement(root.host) ? root.host : null;
+    }
+    return null;
+}
+const TooltipTrigger_TooltipTrigger = fastComponentRef(function(componentProps, forwardedRef) {
+    const { render, className, style, handle, payload, disabled: disabledProp, delay, closeOnClick = true, closeDelay, id: idProp, ...elementProps } = componentProps;
+    const rootContext = useTooltipRootContext(true);
+    const store = handle?.store ?? rootContext;
+    if (!store) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle.' : esm_formatErrorMessage(82));
+    const thisTriggerId = useBaseUiId(idProp);
+    const isTriggerActive = store.useState('isTriggerActive', thisTriggerId);
+    const isOpenedByThisTrigger = store.useState('isOpenedByTrigger', thisTriggerId);
+    const floatingRootContext = store.useState('floatingRootContext');
+    const triggerElementRef = __rspack_external_react.useRef(null);
+    const delayWithDefault = delay ?? 600;
+    const closeDelayWithDefault = closeDelay ?? 0;
+    const { registerTrigger, isMountedByThisTrigger } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+        payload,
+        closeOnClick,
+        closeDelay: closeDelayWithDefault
+    });
+    const providerContext = useTooltipProviderContext();
+    const { delayRef, isInstantPhase, hasProvider } = useDelayGroup(floatingRootContext, {
+        open: isOpenedByThisTrigger
+    });
+    const hoverInteraction = useHoverInteractionSharedState(floatingRootContext);
+    store.useSyncedValue('isInstantPhase', isInstantPhase);
+    const rootDisabled = store.useState('disabled');
+    const disabled = disabledProp ?? rootDisabled;
+    const disabledRef = useValueAsRef(disabled);
+    const trackCursorAxis = store.useState('trackCursorAxis');
+    const disableHoverablePopup = store.useState('disableHoverablePopup');
+    const isNestedTriggerHoveredRef = __rspack_external_react.useRef(false);
+    const nestedTriggerOpenTimeout = useTimeout();
+    const pointerTypeRef = __rspack_external_react.useRef(void 0);
+    function getOpenDelay() {
+        const providerDelay = providerContext?.delay;
+        const groupOpenValue = 'object' == typeof delayRef.current ? delayRef.current.open : void 0;
+        let computedOpenDelay = delayWithDefault;
+        if (hasProvider) computedOpenDelay = 0 !== groupOpenValue ? delay ?? providerDelay ?? delayWithDefault : 0;
+        return computedOpenDelay;
+    }
+    function isEnabledNestedTriggerTarget(target) {
+        const triggerEl = triggerElementRef.current;
+        if (!triggerEl || !target) return false;
+        const nearestTrigger = closestEnabledTooltipTrigger(target);
+        return null !== nearestTrigger && nearestTrigger !== triggerEl && contains(triggerEl, nearestTrigger);
+    }
+    function detectNestedTriggerHover(target) {
+        const nestedTriggerHovered = isEnabledNestedTriggerTarget(target);
+        isNestedTriggerHoveredRef.current = nestedTriggerHovered;
+        if (nestedTriggerHovered) {
+            hoverInteraction.openChangeTimeout.clear();
+            hoverInteraction.restTimeout.clear();
+            hoverInteraction.restTimeoutPending = false;
+            nestedTriggerOpenTimeout.clear();
+        }
+        return nestedTriggerHovered;
+    }
+    const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
+        enabled: !disabled,
+        mouseOnly: true,
+        move: false,
+        handleClose: disableHoverablePopup || 'both' === trackCursorAxis ? null : safePolygon(),
+        restMs: getOpenDelay,
+        delay () {
+            const closeValue = 'object' == typeof delayRef.current ? delayRef.current.close : void 0;
+            let computedCloseDelay = closeDelayWithDefault;
+            if (null == closeDelay && hasProvider) computedCloseDelay = closeValue;
+            return {
+                close: computedCloseDelay
+            };
+        },
+        triggerElementRef,
+        isActiveTrigger: isTriggerActive,
+        isClosing: ()=>'ending' === store.select('transitionStatus'),
+        shouldOpen () {
+            return !isNestedTriggerHoveredRef.current;
+        }
+    });
+    const focusProps = useFocus(floatingRootContext, {
+        enabled: !disabled
+    }).reference;
+    const handleNestedTriggerHover = (event)=>{
+        const wasNestedTriggerHovered = isNestedTriggerHoveredRef.current;
+        const target = getTargetElement(event);
+        const nestedTriggerHovered = detectNestedTriggerHover(target);
+        const triggerEl = triggerElementRef.current;
+        const targetInsideTrigger = triggerEl && target && contains(triggerEl, target);
+        if (nestedTriggerHovered && store.select('open') && store.select('lastOpenChangeReason') === triggerHover) return void store.setOpen(false, createChangeEventDetails(triggerHover, event));
+        if (wasNestedTriggerHovered && !nestedTriggerHovered && targetInsideTrigger && !disabledRef.current && !store.select('open') && triggerEl && isMouseLikePointerType(pointerTypeRef.current)) {
+            const open = ()=>{
+                if (!isNestedTriggerHoveredRef.current && !disabledRef.current && !store.select('open')) store.setOpen(true, createChangeEventDetails(triggerHover, event, triggerEl));
+            };
+            const openDelay = getOpenDelay();
+            if (0 === openDelay) {
+                nestedTriggerOpenTimeout.clear();
+                open();
+            } else nestedTriggerOpenTimeout.start(openDelay, open);
+        }
+    };
+    const rootTriggerProps = store.useState('triggerProps', isMountedByThisTrigger);
+    const shouldApplyRootTriggerProps = isMountedByThisTrigger || 'none' !== trackCursorAxis;
+    const state = {
+        open: isOpenedByThisTrigger
+    };
+    const element = useRenderElement('button', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            registerTrigger,
+            triggerElementRef
+        ],
+        props: [
+            hoverProps,
+            focusProps,
+            shouldApplyRootTriggerProps ? rootTriggerProps : void 0,
+            {
+                onMouseOver (event) {
+                    handleNestedTriggerHover(event.nativeEvent);
+                },
+                onFocus (event) {
+                    if (isEnabledNestedTriggerTarget(getTargetElement(event.nativeEvent))) event.preventBaseUIHandler();
+                },
+                onMouseLeave () {
+                    isNestedTriggerHoveredRef.current = false;
+                    nestedTriggerOpenTimeout.clear();
+                    pointerTypeRef.current = void 0;
+                },
+                onPointerEnter (event) {
+                    pointerTypeRef.current = event.pointerType;
+                },
+                onPointerDown (event) {
+                    pointerTypeRef.current = event.pointerType;
+                    store.set('closeOnClick', closeOnClick);
+                    if (closeOnClick && !store.select('open')) store.cancelPendingOpen(event.nativeEvent);
+                },
+                onClick (event) {
+                    if (closeOnClick && !store.select('open')) store.cancelPendingOpen(event.nativeEvent);
+                },
+                id: thisTriggerId,
+                [TooltipTriggerDataAttributes_TooltipTriggerDataAttributes.triggerDisabled]: disabled ? '' : void 0,
+                [TOOLTIP_TRIGGER_IDENTIFIER]: disabled ? void 0 : ''
+            },
+            elementProps
+        ],
+        stateAttributesMapping: triggerOpenStateMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) TooltipTrigger_TooltipTrigger.displayName = "TooltipTrigger";
+const TooltipPositionerContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) TooltipPositionerContext.displayName = "TooltipPositionerContext";
+function useTooltipPositionerContext() {
+    const context = __rspack_external_react.useContext(TooltipPositionerContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>.' : esm_formatErrorMessage(71));
+    return context;
+}
+const TooltipPortalContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) TooltipPortalContext.displayName = "TooltipPortalContext";
+function useTooltipPortalContext() {
+    const value = __rspack_external_react.useContext(TooltipPortalContext);
+    if (void 0 === value) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: <Tooltip.Portal> is missing.' : esm_formatErrorMessage(70));
+    return value;
+}
+const TooltipPositioner_TooltipPositioner = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, anchor, positionMethod = 'absolute', side = 'top', align = 'center', sideOffset = 0, alignOffset = 0, collisionBoundary = 'clipping-ancestors', collisionPadding = 5, arrowPadding = 5, sticky = false, disableAnchorTracking = false, collisionAvoidance = POPUP_COLLISION_AVOIDANCE, style, ...elementProps } = componentProps;
+    const store = useTooltipRootContext();
+    const keepMounted = useTooltipPortalContext();
+    const open = store.useState('open');
+    const mounted = store.useState('mounted');
+    const trackCursorAxis = store.useState('trackCursorAxis');
+    const disableHoverablePopup = store.useState('disableHoverablePopup');
+    const floatingRootContext = store.useState('floatingRootContext');
+    const instantType = store.useState('instantType');
+    const transitionStatus = store.useState('transitionStatus');
+    const hasViewport = store.useState('hasViewport');
+    const positioning = useAnchorPositioning({
+        anchor,
+        positionMethod,
+        floatingRootContext,
+        mounted,
+        side,
+        sideOffset,
+        align,
+        alignOffset,
+        collisionBoundary,
+        collisionPadding,
+        sticky,
+        arrowPadding,
+        disableAnchorTracking,
+        keepMounted,
+        collisionAvoidance,
+        adaptiveOrigin: hasViewport ? adaptiveOriginMiddleware_adaptiveOrigin : void 0
+    });
+    const state = __rspack_external_react.useMemo(()=>({
+            open,
+            side: positioning.side,
+            align: positioning.align,
+            anchorHidden: positioning.anchorHidden,
+            instant: 'none' !== trackCursorAxis ? 'tracking-cursor' : instantType
+        }), [
+        open,
+        positioning.side,
+        positioning.align,
+        positioning.anchorHidden,
+        trackCursorAxis,
+        instantType
+    ]);
+    const element = usePositioner(componentProps, state, {
+        styles: positioning.positionerStyles,
+        transitionStatus,
+        props: elementProps,
+        refs: [
+            forwardedRef,
+            store.useStateSetter('positionerElement')
+        ],
+        hidden: !mounted,
+        inert: !open || 'both' === trackCursorAxis || disableHoverablePopup
+    });
+    return /*#__PURE__*/ jsx(TooltipPositionerContext.Provider, {
+        value: positioning,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) TooltipPositioner_TooltipPositioner.displayName = "TooltipPositioner";
+const stateAttributesMapping = {
+    ...popupStateMapping,
+    ...transitionStatusMapping
+};
+const TooltipPopup_TooltipPopup = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const store = useTooltipRootContext();
+    const { side, align } = useTooltipPositionerContext();
+    const open = store.useState('open');
+    const instantType = store.useState('instantType');
+    const transitionStatus = store.useState('transitionStatus');
+    const popupProps = store.useState('popupProps');
+    const floatingContext = store.useState('floatingRootContext');
+    const disabled = store.useState('disabled');
+    const closeDelay = store.useState('closeDelay');
+    useOpenChangeComplete({
+        open,
+        ref: store.context.popupRef,
+        onComplete () {
+            if (open) store.context.onOpenChangeComplete?.(true);
+        }
+    });
+    useHoverFloatingInteraction(floatingContext, {
+        enabled: !disabled,
+        closeDelay
+    });
+    const setPopupElement = store.useStateSetter('popupElement');
+    const state = {
+        open,
+        side,
+        align,
+        instant: instantType,
+        transitionStatus
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            store.context.popupRef,
+            setPopupElement
+        ],
+        props: [
+            popupProps,
+            getDisabledMountTransitionStyles(transitionStatus),
+            elementProps
+        ],
+        stateAttributesMapping: stateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) TooltipPopup_TooltipPopup.displayName = "TooltipPopup";
+const TooltipArrow_TooltipArrow = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const store = useTooltipRootContext();
+    const { arrowRef, side, align, arrowUncentered, arrowStyles } = useTooltipPositionerContext();
+    const open = store.useState('open');
+    const instantType = store.useState('instantType');
+    const state = {
+        open,
+        side,
+        align,
+        uncentered: arrowUncentered,
+        instant: instantType
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: [
+            forwardedRef,
+            arrowRef
+        ],
+        props: [
+            {
+                style: arrowStyles,
+                'aria-hidden': true
+            },
+            elementProps
+        ],
+        stateAttributesMapping: popupStateMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) TooltipArrow_TooltipArrow.displayName = "TooltipArrow";
+let TooltipViewportCssVars_TooltipViewportCssVars = /*#__PURE__*/ function(TooltipViewportCssVars) {
+    TooltipViewportCssVars["popupWidth"] = "--popup-width";
+    TooltipViewportCssVars["popupHeight"] = "--popup-height";
+    return TooltipViewportCssVars;
+}({});
+const TooltipViewport_stateAttributesMapping = {
+    activationDirection: (value)=>value ? {
+            'data-activation-direction': value
+        } : null
+};
+const TooltipViewport_TooltipViewport = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, children, ...elementProps } = componentProps;
+    const store = useTooltipRootContext();
+    const positioner = useTooltipPositionerContext();
+    const instantType = store.useState('instantType');
+    const { children: childrenToRender, state: viewportState } = usePopupViewport({
+        store,
+        side: positioner.side,
+        cssVars: TooltipViewportCssVars_TooltipViewportCssVars,
+        children
+    });
+    const state = {
+        activationDirection: viewportState.activationDirection,
+        transitioning: viewportState.transitioning,
+        instant: instantType
+    };
+    return useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            elementProps,
+            {
+                children: childrenToRender
+            }
+        ],
+        stateAttributesMapping: TooltipViewport_stateAttributesMapping
+    });
+});
+if ("production" !== process.env.NODE_ENV) TooltipViewport_TooltipViewport.displayName = "TooltipViewport";
+function createVirtualElement(domElement, data) {
+    let offsetX = null;
+    let offsetY = null;
+    let isAutoUpdateEvent = false;
+    return {
+        contextElement: domElement || void 0,
+        getBoundingClientRect () {
+            const domRect = domElement?.getBoundingClientRect() || {
+                width: 0,
+                height: 0,
+                x: 0,
+                y: 0
+            };
+            const isXAxis = 'x' === data.axis || 'both' === data.axis;
+            const isYAxis = 'y' === data.axis || 'both' === data.axis;
+            const canTrackCursorOnAutoUpdate = [
+                'mouseenter',
+                'mousemove'
+            ].includes(data.dataRef.current.openEvent?.type || '') && 'touch' !== data.pointerType;
+            let width = domRect.width;
+            let height = domRect.height;
+            let x = domRect.x;
+            let y = domRect.y;
+            if (null == offsetX && data.x && isXAxis) offsetX = domRect.x - data.x;
+            if (null == offsetY && data.y && isYAxis) offsetY = domRect.y - data.y;
+            x -= offsetX || 0;
+            y -= offsetY || 0;
+            width = 0;
+            height = 0;
+            if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {
+                width = 'y' === data.axis ? domRect.width : 0;
+                height = 'x' === data.axis ? domRect.height : 0;
+                x = isXAxis && null != data.x ? data.x : x;
+                y = isYAxis && null != data.y ? data.y : y;
+            } else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {
+                height = 'x' === data.axis ? domRect.height : height;
+                width = 'y' === data.axis ? domRect.width : width;
+            }
+            isAutoUpdateEvent = true;
+            return {
+                width,
+                height,
+                x,
+                y,
+                top: y,
+                right: x + width,
+                bottom: y + height,
+                left: x
+            };
+        }
+    };
+}
+function isMouseBasedEvent(event) {
+    return null != event && null != event.clientX;
+}
+function useClientPoint(context, props = {}) {
+    const { enabled = true, axis = 'both' } = props;
+    const store = 'rootStore' in context ? context.rootStore : context;
+    const open = store.useState('open');
+    const floating = store.useState('floatingElement');
+    const domReference = store.useState('domReferenceElement');
+    const dataRef = store.context.dataRef;
+    const initialRef = __rspack_external_react.useRef(false);
+    const cleanupListenerRef = __rspack_external_react.useRef(null);
+    const [pointerType, setPointerType] = __rspack_external_react.useState();
+    const [reactive, setReactive] = __rspack_external_react.useState([]);
+    const resetReference = useStableCallback((reference)=>{
+        store.set('positionReference', reference);
+    });
+    const setReference = useStableCallback((newX, newY, referenceElement)=>{
+        if (initialRef.current) return;
+        if (dataRef.current.openEvent && !isMouseBasedEvent(dataRef.current.openEvent)) return;
+        store.set('positionReference', createVirtualElement(referenceElement ?? domReference, {
+            x: newX,
+            y: newY,
+            axis,
+            dataRef,
+            pointerType
+        }));
+    });
+    const handleReferenceEnterOrMove = useStableCallback((event)=>{
+        if (open) {
+            if (!cleanupListenerRef.current) {
+                setReference(event.clientX, event.clientY, event.currentTarget);
+                setReactive([]);
+            }
+        } else setReference(event.clientX, event.clientY, event.currentTarget);
+    });
+    const openCheck = isMouseLikePointerType(pointerType) ? floating : open;
+    __rspack_external_react.useEffect(()=>{
+        if (!enabled) return void resetReference(domReference);
+        if (!openCheck) return;
+        function cleanupListener() {
+            cleanupListenerRef.current?.();
+            cleanupListenerRef.current = null;
+        }
+        const win = getWindow(floating);
+        function handleMouseMove(event) {
+            const target = getTarget(event);
+            if (contains(floating, target)) cleanupListener();
+            else setReference(event.clientX, event.clientY);
+        }
+        if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) cleanupListenerRef.current = addEventListener(win, 'mousemove', handleMouseMove);
+        else resetReference(domReference);
+        return cleanupListener;
+    }, [
+        openCheck,
+        enabled,
+        floating,
+        dataRef,
+        domReference,
+        store,
+        setReference,
+        resetReference,
+        reactive
+    ]);
+    __rspack_external_react.useEffect(()=>()=>{
+            store.set('positionReference', null);
+        }, [
+        store
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (enabled && !floating) initialRef.current = false;
+    }, [
+        enabled,
+        floating
+    ]);
+    __rspack_external_react.useEffect(()=>{
+        if (!enabled && open) initialRef.current = true;
+    }, [
+        enabled,
+        open
+    ]);
+    const reference = __rspack_external_react.useMemo(()=>{
+        function setPointerTypeRef(event) {
+            setPointerType(event.pointerType);
+        }
+        return {
+            onPointerDown: setPointerTypeRef,
+            onPointerEnter: setPointerTypeRef,
+            onMouseMove: handleReferenceEnterOrMove,
+            onMouseEnter: handleReferenceEnterOrMove
+        };
+    }, [
+        handleReferenceEnterOrMove
+    ]);
+    return __rspack_external_react.useMemo(()=>enabled ? {
+            reference,
+            trigger: reference
+        } : {}, [
+        enabled,
+        reference
+    ]);
+}
+const selectors = {
+    ...popupStoreSelectors,
+    disabled: createSelector((state)=>state.disabled),
+    instantType: createSelector((state)=>state.instantType),
+    isInstantPhase: createSelector((state)=>state.isInstantPhase),
+    trackCursorAxis: createSelector((state)=>state.trackCursorAxis),
+    disableHoverablePopup: createSelector((state)=>state.disableHoverablePopup),
+    lastOpenChangeReason: createSelector((state)=>state.openChangeReason),
+    closeOnClick: createSelector((state)=>state.closeOnClick),
+    closeDelay: createSelector((state)=>state.closeDelay),
+    hasViewport: createSelector((state)=>state.hasViewport)
+};
+class TooltipStore extends ReactStore {
+    constructor(initialState, floatingId, nested = false){
+        const triggerElements = new PopupTriggerMap();
+        const state = {
+            ...createInitialState(),
+            ...initialState
+        };
+        state.floatingRootContext = createPopupFloatingRootContext(triggerElements, floatingId, nested);
+        super(state, {
+            popupRef: /*#__PURE__*/ __rspack_external_react.createRef(),
+            onOpenChange: void 0,
+            onOpenChangeComplete: void 0,
+            triggerElements
+        }, selectors);
+    }
+    setOpen = (nextOpen, eventDetails)=>{
+        const reason = eventDetails.reason;
+        const isHover = reason === triggerHover;
+        const isFocusOpen = nextOpen && reason === triggerFocus;
+        const isDismissClose = !nextOpen && (reason === triggerPress || reason === escapeKey);
+        eventDetails.preventUnmountOnClose = ()=>{
+            this.set('preventUnmountingOnClose', true);
+        };
+        this.context.onOpenChange?.(nextOpen, eventDetails);
+        if (eventDetails.isCanceled) return;
+        this.state.floatingRootContext.dispatchOpenChange(nextOpen, eventDetails);
+        const changeState = ()=>{
+            const updatedState = {
+                open: nextOpen,
+                openChangeReason: reason
+            };
+            if (isFocusOpen) updatedState.instantType = 'focus';
+            else if (isDismissClose) updatedState.instantType = 'dismiss';
+            else if (reason === triggerHover) updatedState.instantType = void 0;
+            setOpenTriggerState(updatedState, nextOpen, eventDetails.trigger);
+            this.update(updatedState);
+        };
+        if (isHover) __rspack_external_react_dom_7136dc57.flushSync(changeState);
+        else changeState();
+    };
+    cancelPendingOpen(event) {
+        this.state.floatingRootContext.dispatchOpenChange(false, createChangeEventDetails(triggerPress, event));
+    }
+    static useStore(externalStore, initialState) {
+        const store = usePopupStore(externalStore, (floatingId, nested)=>new TooltipStore(initialState, floatingId, nested)).store;
+        return store;
+    }
+}
+function createInitialState() {
+    return {
+        ...createInitialPopupStoreState(),
+        disabled: false,
+        instantType: void 0,
+        isInstantPhase: false,
+        trackCursorAxis: 'none',
+        disableHoverablePopup: false,
+        openChangeReason: null,
+        closeOnClick: true,
+        closeDelay: 0,
+        hasViewport: false
+    };
+}
+const TooltipRoot_TooltipRoot = fastComponent(function(props) {
+    const { disabled = false, defaultOpen = false, open: openProp, disableHoverablePopup = false, trackCursorAxis = 'none', actionsRef, onOpenChange, onOpenChangeComplete, handle, triggerId: triggerIdProp, defaultTriggerId: defaultTriggerIdProp = null, children } = props;
+    const store = TooltipStore.useStore(handle?.store, {
+        open: defaultOpen,
+        openProp,
+        activeTriggerId: defaultTriggerIdProp,
+        triggerIdProp
+    });
+    useOnFirstRender(()=>{
+        if (void 0 === openProp && false === store.state.open && true === defaultOpen) store.update({
+            open: true,
+            activeTriggerId: defaultTriggerIdProp
+        });
+    });
+    store.useControlledProp('openProp', openProp);
+    store.useControlledProp('triggerIdProp', triggerIdProp);
+    store.useContextCallback('onOpenChange', onOpenChange);
+    store.useContextCallback('onOpenChangeComplete', onOpenChangeComplete);
+    const openState = store.useState('open');
+    const open = !disabled && openState;
+    const activeTriggerId = store.useState('activeTriggerId');
+    const mounted = store.useState('mounted');
+    const payload = store.useState('payload');
+    store.useSyncedValues({
+        trackCursorAxis,
+        disableHoverablePopup
+    });
+    store.useSyncedValue('disabled', disabled);
+    useImplicitActiveTrigger(store);
+    const { forceUnmount, transitionStatus } = useOpenStateTransitions(open, store);
+    const isInstantPhase = store.useState('isInstantPhase');
+    const instantType = store.useState('instantType');
+    const lastOpenChangeReason = store.useState('lastOpenChangeReason');
+    const previousInstantTypeRef = __rspack_external_react.useRef(null);
+    useIsoLayoutEffect(()=>{
+        if (openState && disabled) store.setOpen(false, createChangeEventDetails(reason_parts_disabled));
+    }, [
+        openState,
+        disabled,
+        store
+    ]);
+    useIsoLayoutEffect(()=>{
+        if ('ending' === transitionStatus && "none" === lastOpenChangeReason || 'ending' !== transitionStatus && isInstantPhase) {
+            if ('delay' !== instantType) previousInstantTypeRef.current = instantType;
+            store.set('instantType', 'delay');
+        } else if (null !== previousInstantTypeRef.current) {
+            store.set('instantType', previousInstantTypeRef.current);
+            previousInstantTypeRef.current = null;
+        }
+    }, [
+        transitionStatus,
+        isInstantPhase,
+        lastOpenChangeReason,
+        instantType,
+        store
+    ]);
+    useIsoLayoutEffect(()=>{
+        if (open) {
+            if (null == activeTriggerId) store.set('payload', void 0);
+        }
+    }, [
+        store,
+        activeTriggerId,
+        open
+    ]);
+    const handleImperativeClose = __rspack_external_react.useCallback(()=>{
+        store.setOpen(false, createChangeEventDetails(imperativeAction));
+    }, [
+        store
+    ]);
+    __rspack_external_react.useImperativeHandle(actionsRef, ()=>({
+            unmount: forceUnmount,
+            close: handleImperativeClose
+        }), [
+        forceUnmount,
+        handleImperativeClose
+    ]);
+    const shouldRenderInteractions = open || mounted || !disabled && 'none' !== trackCursorAxis;
+    return /*#__PURE__*/ jsxs(TooltipRootContext.Provider, {
+        value: store,
+        children: [
+            shouldRenderInteractions && /*#__PURE__*/ jsx(TooltipInteractions, {
+                store: store,
+                disabled: disabled,
+                trackCursorAxis: trackCursorAxis
+            }),
+            'function' == typeof children ? children({
+                payload
+            }) : children
+        ]
+    });
+});
+if ("production" !== process.env.NODE_ENV) TooltipRoot_TooltipRoot.displayName = "TooltipRoot";
+function TooltipInteractions({ store, disabled, trackCursorAxis }) {
+    const floatingRootContext = store.useState('floatingRootContext');
+    const dismiss = useDismiss(floatingRootContext, {
+        enabled: !disabled,
+        referencePress: ()=>store.select('closeOnClick')
+    });
+    const clientPoint = useClientPoint(floatingRootContext, {
+        enabled: !disabled && 'none' !== trackCursorAxis,
+        axis: 'none' === trackCursorAxis ? void 0 : trackCursorAxis
+    });
+    const activeTriggerProps = __rspack_external_react.useMemo(()=>mergeProps(clientPoint.reference, dismiss.reference), [
+        clientPoint.reference,
+        dismiss.reference
+    ]);
+    const inactiveTriggerProps = __rspack_external_react.useMemo(()=>mergeProps(clientPoint.trigger, dismiss.trigger), [
+        clientPoint.trigger,
+        dismiss.trigger
+    ]);
+    const popupProps = __rspack_external_react.useMemo(()=>mergeProps(FOCUSABLE_POPUP_PROPS, clientPoint.floating, dismiss.floating), [
+        clientPoint.floating,
+        dismiss.floating
+    ]);
+    usePopupInteractionProps(store, {
+        activeTriggerProps,
+        inactiveTriggerProps,
+        popupProps
+    });
+    return null;
+}
+const TooltipPortal_TooltipPortal = /*#__PURE__*/ __rspack_external_react.forwardRef(function(props, forwardedRef) {
+    const { keepMounted = false, ...portalProps } = props;
+    const store = useTooltipRootContext();
+    const mounted = store.useState('mounted');
+    const shouldRender = mounted || keepMounted;
+    if (!shouldRender) return null;
+    return /*#__PURE__*/ jsx(TooltipPortalContext.Provider, {
+        value: keepMounted,
+        children: /*#__PURE__*/ jsx(FloatingPortalLite_FloatingPortalLite, {
+            ref: forwardedRef,
+            ...portalProps
+        })
+    });
+});
+if ("production" !== process.env.NODE_ENV) TooltipPortal_TooltipPortal.displayName = "TooltipPortal";
+const TooltipProvider_TooltipProvider = function(props) {
+    const { delay, closeDelay, timeout = 400 } = props;
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            delay,
+            closeDelay
+        }), [
+        delay,
+        closeDelay
+    ]);
+    const delayValue = __rspack_external_react.useMemo(()=>({
+            open: delay,
+            close: closeDelay
+        }), [
+        delay,
+        closeDelay
+    ]);
+    return /*#__PURE__*/ jsx(TooltipProviderContext.Provider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx(FloatingDelayGroup, {
+            delay: delayValue,
+            timeoutMs: timeout,
+            children: props.children
+        })
+    });
+};
+if ("production" !== process.env.NODE_ENV) TooltipProvider_TooltipProvider.displayName = "TooltipProvider";
+class TooltipHandle {
+    constructor(){
+        this.store = new TooltipStore();
+    }
+    open(triggerId) {
+        const triggerElement = triggerId ? this.store.context.triggerElements.getById(triggerId) : void 0;
+        if (triggerId && !triggerElement) throw new Error("production" !== process.env.NODE_ENV ? `Base UI: TooltipHandle.open: No trigger found with id "${triggerId}".` : esm_formatErrorMessage(81, triggerId));
+        this.store.setOpen(true, createChangeEventDetails(imperativeAction, void 0, triggerElement));
+    }
+    close() {
+        this.store.setOpen(false, createChangeEventDetails(imperativeAction, void 0, void 0));
+    }
+    get isOpen() {
+        return this.store.select('open');
+    }
+}
+function createTooltipHandle() {
+    return new TooltipHandle();
+}
 const Tooltip_module = {
     trigger: "trigger-xVlrp2",
     positioner: "positioner-sRKHj5",
@@ -9,41 +960,41 @@ const Tooltip_module = {
     arrow: "arrow-aUAEXL"
 };
 function Trigger({ className, ...props }) {
-    return /*#__PURE__*/ jsx(Tooltip.Trigger, {
+    return /*#__PURE__*/ jsx(TooltipTrigger_TooltipTrigger, {
         ...props,
         className: clsx(Tooltip_module.trigger, className)
     });
 }
-const Positioner = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Tooltip.Positioner, {
+const Positioner = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(TooltipPositioner_TooltipPositioner, {
         ref: ref,
         className: clsx(Tooltip_module.positioner, className),
         ...props
     }));
-const Popup = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Tooltip.Popup, {
+const Popup = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(TooltipPopup_TooltipPopup, {
         ref: ref,
         className: clsx(Tooltip_module.popup, className),
         ...props
     }));
-const Arrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Tooltip.Arrow, {
+const Arrow = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(TooltipArrow_TooltipArrow, {
         ref: ref,
         className: clsx(Tooltip_module.arrow, className),
         ...props
     }));
-const Viewport = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Tooltip.Viewport, {
+const Viewport = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(TooltipViewport_TooltipViewport, {
         ref: ref,
         className: clsx(Tooltip_module.viewport, className),
         ...props
     }));
-const Tooltip_Tooltip = {
+const Tooltip = {
     Trigger: Trigger,
     Positioner: Positioner,
     Popup: Popup,
     Arrow: Arrow,
     Viewport: Viewport,
-    Root: Tooltip.Root,
-    Portal: Tooltip.Portal,
-    Provider: Tooltip.Provider,
-    Handle: Tooltip.Handle,
-    createHandle: Tooltip.createHandle
+    Root: TooltipRoot_TooltipRoot,
+    Portal: TooltipPortal_TooltipPortal,
+    Provider: TooltipProvider_TooltipProvider,
+    Handle: TooltipHandle,
+    createHandle: createTooltipHandle
 };
-export { Tooltip_Tooltip as Tooltip };
+export { Tooltip };