@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/tooltip.cjs

@@ -0,0 +1,835 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tooltip_exports = {};
+__export(tooltip_exports, {
+  OPEN_DELAY: () => OPEN_DELAY,
+  Tooltip: () => Tooltip,
+  TooltipHandle: () => TooltipHandle,
+  TooltipStore: () => TooltipStore,
+  TooltipTriggerDataAttributes: () => TooltipTriggerDataAttributes,
+  TooltipViewportCssVars: () => TooltipViewportCssVars,
+  createTooltipHandle: () => createTooltipHandle,
+  useTooltipPositionerContext: () => useTooltipPositionerContext,
+  useTooltipRootContext: () => useTooltipRootContext
+});
+module.exports = __toCommonJS(tooltip_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+var import_useRenderElement = require("./utils/useRenderElement.cjs");
+var import_mergeProps = require("./utils/mergeProps.cjs");
+var import_useBaseUiId = require("./utils/useBaseUiId.cjs");
+var import_createChangeEventDetails = require("./utils/createChangeEventDetails.cjs");
+var import_ReactStore = require("./utils/store/ReactStore.cjs");
+var import_createSelector = require("./utils/store/createSelector.cjs");
+var import_useTimeout = require("./utils/useTimeout.cjs");
+var import_useValueAsRef = require("./utils/useValueAsRef.cjs");
+var import_octane2 = require("octane");
+var import_useDismiss = require("./utils/floating/useDismiss.cjs");
+var import_useClientPoint = require("./utils/floating/useClientPoint.cjs");
+var import_useFocus = require("./utils/floating/useFocus.cjs");
+var import_FloatingDelayGroup = require("./utils/floating/FloatingDelayGroup.cjs");
+var import_useHoverReferenceInteraction = require("./utils/floating/useHoverReferenceInteraction.cjs");
+var import_useHoverFloatingInteraction = require("./utils/floating/useHoverFloatingInteraction.cjs");
+var import_useHoverInteractionSharedState = require("./utils/floating/useHoverInteractionSharedState.cjs");
+var import_element = require("./utils/floating/element.cjs");
+var import_event = require("./utils/floating/event.cjs");
+var import_dom = require("./utils/dom.cjs");
+var import_FloatingPortalLite = require("./utils/FloatingPortalLite.cjs");
+var import_useAnchorPositioning = require("./utils/useAnchorPositioning.cjs");
+var import_usePositioner = require("./utils/usePositioner.cjs");
+var import_usePopupViewport = require("./utils/usePopupViewport.cjs");
+var import_adaptiveOriginMiddleware = require("./utils/adaptiveOriginMiddleware.cjs");
+var import_useOpenChangeComplete = require("./utils/useOpenChangeComplete.cjs");
+var import_getDisabledMountTransitionStyles = require("./utils/getDisabledMountTransitionStyles.cjs");
+var import_constants = require("./utils/constants.cjs");
+var import_popupStateMapping = require("./utils/popupStateMapping.cjs");
+var import_useTransitionStatus = require("./utils/useTransitionStatus.cjs");
+var import_popups = require("./utils/popups/index.cjs");
+var import_popupTriggerMap = require("./utils/popups/popupTriggerMap.cjs");
+const OPEN_DELAY = 600;
+const TOOLTIP_TRIGGER_IDENTIFIER = "data-base-ui-tooltip-trigger";
+const TooltipTriggerDataAttributes = {
+  popupOpen: import_popupStateMapping.CommonTriggerDataAttributes.popupOpen,
+  triggerDisabled: "data-trigger-disabled"
+};
+const TooltipViewportCssVars = {
+  popupWidth: "--popup-width",
+  popupHeight: "--popup-height"
+};
+const tooltipSelectors = {
+  ...import_popups.popupStoreSelectors,
+  disabled: (0, import_createSelector.createSelector)((state) => state.disabled),
+  instantType: (0, import_createSelector.createSelector)((state) => state.instantType),
+  isInstantPhase: (0, import_createSelector.createSelector)((state) => state.isInstantPhase),
+  trackCursorAxis: (0, import_createSelector.createSelector)((state) => state.trackCursorAxis),
+  disableHoverablePopup: (0, import_createSelector.createSelector)(
+    (state) => state.disableHoverablePopup
+  ),
+  lastOpenChangeReason: (0, import_createSelector.createSelector)((state) => state.openChangeReason),
+  closeOnClick: (0, import_createSelector.createSelector)((state) => state.closeOnClick),
+  closeDelay: (0, import_createSelector.createSelector)((state) => state.closeDelay),
+  hasViewport: (0, import_createSelector.createSelector)((state) => state.hasViewport)
+};
+function createInitialTooltipState() {
+  return {
+    ...(0, import_popups.createInitialPopupStoreState)(),
+    disabled: false,
+    instantType: void 0,
+    isInstantPhase: false,
+    trackCursorAxis: "none",
+    disableHoverablePopup: false,
+    openChangeReason: null,
+    closeOnClick: true,
+    closeDelay: 0,
+    hasViewport: false
+  };
+}
+class TooltipStore extends import_ReactStore.ReactStore {
+  constructor(initialState, floatingId, nested = false) {
+    const triggerElements = new import_popupTriggerMap.PopupTriggerMap();
+    const state = { ...createInitialTooltipState(), ...initialState };
+    state.floatingRootContext = (0, import_popups.createPopupFloatingRootContext)(triggerElements, floatingId, nested);
+    super(
+      state,
+      {
+        popupRef: { current: null },
+        onOpenChange: void 0,
+        onOpenChangeComplete: void 0,
+        triggerElements
+      },
+      tooltipSelectors
+    );
+  }
+  setOpen = (nextOpen, eventDetails) => {
+    (0, import_popups.applyPopupOpenChange)(this, nextOpen, eventDetails, {
+      extraState: { openChangeReason: eventDetails.reason }
+    });
+  };
+  // Used by trigger clicks to clear a delayed hover open without reporting a public state change.
+  cancelPendingOpen(event) {
+    this.state.floatingRootContext.dispatchOpenChange(
+      false,
+      (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.triggerPress, event)
+    );
+  }
+  static useStore(externalStore, initialState, slot) {
+    return (0, import_popups.usePopupStore)(
+      externalStore,
+      (floatingId, nested) => new TooltipStore(initialState, floatingId, nested),
+      true,
+      slot
+    ).store;
+  }
+}
+class TooltipHandle {
+  store;
+  constructor(store) {
+    this.store = store ?? new TooltipStore();
+  }
+  open(triggerId) {
+    const triggerElement = triggerId ? this.store.context.triggerElements.getById(triggerId) : void 0;
+    if (triggerId && !triggerElement) {
+      throw new Error(`Base UI: TooltipHandle.open: No trigger found with id "${triggerId}".`);
+    }
+    this.store.setOpen(
+      true,
+      (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.imperativeAction, void 0, triggerElement)
+    );
+  }
+  close() {
+    this.store.setOpen(
+      false,
+      (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.imperativeAction, void 0, void 0)
+    );
+  }
+  get isOpen() {
+    return this.store.select("open");
+  }
+}
+function createTooltipHandle() {
+  return new TooltipHandle();
+}
+const TooltipRootContext = (0, import_octane.createContext)(void 0);
+function useTooltipRootContext(optional) {
+  const context = (0, import_octane.useContext)(TooltipRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(
+      "Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>."
+    );
+  }
+  return context;
+}
+const TooltipProviderContext = (0, import_octane.createContext)(void 0);
+function useTooltipProviderContext() {
+  return (0, import_octane.useContext)(TooltipProviderContext);
+}
+const TooltipPortalContext = (0, import_octane.createContext)(void 0);
+function useTooltipPortalContext() {
+  const value = (0, import_octane.useContext)(TooltipPortalContext);
+  if (value === void 0) {
+    throw new Error("Base UI: <Tooltip.Portal> is missing.");
+  }
+  return value;
+}
+const TooltipPositionerContext = (0, import_octane.createContext)(
+  void 0
+);
+function useTooltipPositionerContext() {
+  const context = (0, import_octane.useContext)(TooltipPositionerContext);
+  if (!context) {
+    throw new Error(
+      "Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>."
+    );
+  }
+  return context;
+}
+function TooltipProvider(props) {
+  const slot = (0, import_internal.S)("TooltipProvider");
+  const { delay, closeDelay, timeout = 400, children } = props;
+  const contextValue = (0, import_octane.useMemo)(
+    () => ({ delay, closeDelay }),
+    [delay, closeDelay],
+    (0, import_internal.subSlot)(slot, "ctx")
+  );
+  const delayValue = (0, import_octane.useMemo)(
+    () => ({ open: delay, close: closeDelay }),
+    [delay, closeDelay],
+    (0, import_internal.subSlot)(slot, "delay")
+  );
+  return (0, import_octane.createElement)(TooltipProviderContext.Provider, {
+    value: contextValue,
+    children: (0, import_octane.createElement)(import_FloatingDelayGroup.FloatingDelayGroup, {
+      delay: delayValue,
+      timeoutMs: timeout,
+      children
+    })
+  });
+}
+function TooltipInteractions(props) {
+  const slot = (0, import_internal.S)("TooltipInteractions");
+  const { store, disabled, trackCursorAxis } = props;
+  const floatingRootContext = store.useState("floatingRootContext", (0, import_internal.subSlot)(slot, "frc"));
+  const dismiss = (0, import_useDismiss.useDismiss)(
+    floatingRootContext,
+    { enabled: !disabled, referencePress: () => store.select("closeOnClick") },
+    (0, import_internal.subSlot)(slot, "dismiss")
+  );
+  const clientPoint = (0, import_useClientPoint.useClientPoint)(
+    floatingRootContext,
+    {
+      enabled: !disabled && trackCursorAxis !== "none",
+      axis: trackCursorAxis === "none" ? void 0 : trackCursorAxis
+    },
+    (0, import_internal.subSlot)(slot, "cp")
+  );
+  const activeTriggerProps = (0, import_octane.useMemo)(
+    () => (0, import_mergeProps.mergeProps)(clientPoint.reference, dismiss.reference),
+    [clientPoint.reference, dismiss.reference],
+    (0, import_internal.subSlot)(slot, "atp")
+  );
+  const inactiveTriggerProps = (0, import_octane.useMemo)(
+    () => (0, import_mergeProps.mergeProps)(clientPoint.trigger, dismiss.trigger),
+    [clientPoint.trigger, dismiss.trigger],
+    (0, import_internal.subSlot)(slot, "itp")
+  );
+  const popupProps = (0, import_octane.useMemo)(
+    () => (0, import_mergeProps.mergeProps)(import_popups.FOCUSABLE_POPUP_PROPS, clientPoint.floating, dismiss.floating),
+    [clientPoint.floating, dismiss.floating],
+    (0, import_internal.subSlot)(slot, "pp")
+  );
+  (0, import_popups.usePopupInteractionProps)(
+    store,
+    { activeTriggerProps, inactiveTriggerProps, popupProps },
+    (0, import_internal.subSlot)(slot, "pip")
+  );
+  return null;
+}
+function TooltipRoot(props) {
+  const slot = (0, import_internal.S)("TooltipRoot");
+  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
+    },
+    (0, import_internal.subSlot)(slot, "store")
+  );
+  (0, import_popups.useInitialOpenSync)(store, openProp, defaultOpen, defaultTriggerIdProp, (0, import_internal.subSlot)(slot, "ios"));
+  store.useControlledProp("openProp", openProp, (0, import_internal.subSlot)(slot, "cp:open"));
+  store.useControlledProp("triggerIdProp", triggerIdProp, (0, import_internal.subSlot)(slot, "cp:trigger"));
+  store.useContextCallback("onOpenChange", onOpenChange, (0, import_internal.subSlot)(slot, "cb:open"));
+  store.useContextCallback(
+    "onOpenChangeComplete",
+    onOpenChangeComplete,
+    (0, import_internal.subSlot)(slot, "cb:complete")
+  );
+  const openState = store.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const open = !disabled && openState;
+  const activeTriggerId = store.useState("activeTriggerId", (0, import_internal.subSlot)(slot, "atid"));
+  const mounted = store.useState("mounted", (0, import_internal.subSlot)(slot, "mounted"));
+  const payload = store.useState("payload", (0, import_internal.subSlot)(slot, "payload"));
+  store.useSyncedValue("trackCursorAxis", trackCursorAxis, (0, import_internal.subSlot)(slot, "sv:tca"));
+  store.useSyncedValue("disableHoverablePopup", disableHoverablePopup, (0, import_internal.subSlot)(slot, "sv:dhp"));
+  store.useSyncedValue("disabled", disabled, (0, import_internal.subSlot)(slot, "sv:disabled"));
+  (0, import_popups.useImplicitActiveTrigger)(store, { closeOnActiveTriggerUnmount: true }, (0, import_internal.subSlot)(slot, "implicit"));
+  const { forceUnmount, transitionStatus } = (0, import_popups.useOpenStateTransitions)(
+    open,
+    store,
+    void 0,
+    (0, import_internal.subSlot)(slot, "transitions")
+  );
+  const isInstantPhase = store.useState("isInstantPhase", (0, import_internal.subSlot)(slot, "iip"));
+  const instantType = store.useState("instantType", (0, import_internal.subSlot)(slot, "itype"));
+  const lastOpenChangeReason = store.useState("lastOpenChangeReason", (0, import_internal.subSlot)(slot, "locr"));
+  const previousInstantTypeRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "pit"));
+  (0, import_octane2.useLayoutEffect)(
+    () => {
+      if (openState && disabled) {
+        store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.disabled));
+      }
+    },
+    [openState, disabled, store],
+    (0, import_internal.subSlot)(slot, "l:disabled")
+  );
+  (0, import_octane2.useLayoutEffect)(
+    () => {
+      if (transitionStatus === "ending" && lastOpenChangeReason === import_createChangeEventDetails.REASONS.none || transitionStatus !== "ending" && isInstantPhase) {
+        if (instantType !== "delay") {
+          previousInstantTypeRef.current = instantType;
+        }
+        store.set("instantType", "delay");
+      } else if (previousInstantTypeRef.current !== null) {
+        store.set("instantType", previousInstantTypeRef.current);
+        previousInstantTypeRef.current = null;
+      }
+    },
+    [transitionStatus, isInstantPhase, lastOpenChangeReason, instantType, store],
+    (0, import_internal.subSlot)(slot, "l:instant")
+  );
+  (0, import_octane2.useLayoutEffect)(
+    () => {
+      if (open && activeTriggerId == null) {
+        store.set("payload", void 0);
+      }
+    },
+    [store, activeTriggerId, open],
+    (0, import_internal.subSlot)(slot, "l:payload")
+  );
+  const handleImperativeClose = (0, import_octane2.useCallback)(
+    () => {
+      store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.imperativeAction));
+    },
+    [store],
+    (0, import_internal.subSlot)(slot, "close")
+  );
+  (0, import_octane2.useImperativeHandle)(
+    actionsRef,
+    () => ({ unmount: forceUnmount, close: handleImperativeClose }),
+    [forceUnmount, handleImperativeClose],
+    (0, import_internal.subSlot)(slot, "imp")
+  );
+  const shouldRenderInteractions = open || mounted || !disabled && trackCursorAxis !== "none";
+  const resolvedChildren = typeof children === "function" && !(0, import_octane2.isChildrenBlock)(children) ? children({ payload }) : children;
+  const content = [
+    shouldRenderInteractions ? (0, import_octane.createElement)(TooltipInteractions, {
+      key: "interactions",
+      store,
+      disabled,
+      trackCursorAxis
+    }) : null,
+    (0, import_octane.createElement)(import_octane.Fragment, { key: "children", children: resolvedChildren })
+  ];
+  return (0, import_octane.createElement)(TooltipRootContext.Provider, { value: store, children: content });
+}
+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 ((0, import_dom.isElement)(element)) {
+        return element;
+      }
+    }
+  }
+  const target = event.target;
+  if ((0, import_dom.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 && (0, import_dom.isElement)(root.host) ? root.host : null;
+  }
+  return null;
+}
+function TooltipTrigger(componentProps) {
+  const slot = (0, import_internal.S)("TooltipTrigger");
+  const {
+    render,
+    className,
+    style,
+    handle,
+    payload,
+    disabled: disabledProp,
+    delay,
+    closeOnClick = true,
+    closeDelay,
+    id: idProp,
+    ref,
+    ...elementProps
+  } = componentProps;
+  const rootContext = useTooltipRootContext(true);
+  const store = handle?.store ?? rootContext;
+  if (!store) {
+    throw new Error(
+      "Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle."
+    );
+  }
+  const thisTriggerId = (0, import_useBaseUiId.useBaseUiId)(idProp, (0, import_internal.subSlot)(slot, "id"));
+  const isTriggerActive = store.useState("isTriggerActive", (0, import_internal.subSlot)(slot, "ita"), thisTriggerId);
+  const isOpenedByThisTrigger = store.useState(
+    "isOpenedByTrigger",
+    (0, import_internal.subSlot)(slot, "obt"),
+    thisTriggerId
+  );
+  const floatingRootContext = store.useState("floatingRootContext", (0, import_internal.subSlot)(slot, "frc"));
+  const triggerElementRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "trigEl"));
+  const delayWithDefault = delay ?? OPEN_DELAY;
+  const closeDelayWithDefault = closeDelay ?? 0;
+  const { registerTrigger, isMountedByThisTrigger } = (0, import_popups.useTriggerDataForwarding)(
+    thisTriggerId,
+    triggerElementRef,
+    store,
+    { payload, closeOnClick, closeDelay: closeDelayWithDefault },
+    (0, import_internal.subSlot)(slot, "tdf")
+  );
+  const providerContext = useTooltipProviderContext();
+  const { delayRef, isInstantPhase, hasProvider } = (0, import_FloatingDelayGroup.useDelayGroup)(
+    floatingRootContext,
+    { open: isOpenedByThisTrigger },
+    (0, import_internal.subSlot)(slot, "group")
+  );
+  const hoverInteraction = (0, import_useHoverInteractionSharedState.useHoverInteractionSharedState)(
+    floatingRootContext,
+    (0, import_internal.subSlot)(slot, "hoverState")
+  );
+  store.useSyncedValue("isInstantPhase", isInstantPhase, (0, import_internal.subSlot)(slot, "sv:iip"));
+  const rootDisabled = store.useState("disabled", (0, import_internal.subSlot)(slot, "rootDisabled"));
+  const disabled = disabledProp ?? rootDisabled;
+  const disabledRef = (0, import_useValueAsRef.useValueAsRef)(disabled, (0, import_internal.subSlot)(slot, "disabledRef"));
+  const trackCursorAxis = store.useState("trackCursorAxis", (0, import_internal.subSlot)(slot, "tca"));
+  const disableHoverablePopup = store.useState("disableHoverablePopup", (0, import_internal.subSlot)(slot, "dhp"));
+  const isNestedTriggerHoveredRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "nested"));
+  const nestedTriggerOpenTimeout = (0, import_useTimeout.useTimeout)((0, import_internal.subSlot)(slot, "nestedTo"));
+  const pointerTypeRef = (0, import_octane.useRef)(void 0, (0, import_internal.subSlot)(slot, "ptype"));
+  function getOpenDelay() {
+    const providerDelay = providerContext?.delay;
+    const groupOpenValue = typeof delayRef.current === "object" ? delayRef.current.open : void 0;
+    let computedOpenDelay = delayWithDefault;
+    if (hasProvider) {
+      if (groupOpenValue !== 0) {
+        computedOpenDelay = delay ?? providerDelay ?? delayWithDefault;
+      } else {
+        computedOpenDelay = 0;
+      }
+    }
+    return computedOpenDelay;
+  }
+  function isEnabledNestedTriggerTarget(target) {
+    const triggerEl = triggerElementRef.current;
+    if (!triggerEl || !target) {
+      return false;
+    }
+    const nearestTrigger = closestEnabledTooltipTrigger(target);
+    return nearestTrigger !== null && nearestTrigger !== triggerEl && (0, import_element.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 = (0, import_useHoverReferenceInteraction.useHoverReferenceInteraction)(
+    floatingRootContext,
+    {
+      enabled: !disabled,
+      mouseOnly: true,
+      move: false,
+      handleClose: !disableHoverablePopup && trackCursorAxis !== "both" ? (0, import_useHoverReferenceInteraction.safePolygon)() : null,
+      restMs: getOpenDelay,
+      delay() {
+        const closeValue = typeof delayRef.current === "object" ? delayRef.current.close : void 0;
+        let computedCloseDelay = closeDelayWithDefault;
+        if (closeDelay == null && hasProvider) {
+          computedCloseDelay = closeValue;
+        }
+        return { close: computedCloseDelay };
+      },
+      triggerElementRef,
+      isActiveTrigger: isTriggerActive,
+      isClosing: () => store.select("transitionStatus") === "ending",
+      shouldOpen() {
+        return !isNestedTriggerHoveredRef.current;
+      }
+    },
+    (0, import_internal.subSlot)(slot, "hover")
+  );
+  const focusProps = (0, import_useFocus.useFocus)(
+    floatingRootContext,
+    { enabled: !disabled },
+    (0, import_internal.subSlot)(slot, "focus")
+  ).reference;
+  function handleNestedTriggerHover(event) {
+    const wasNestedTriggerHovered = isNestedTriggerHoveredRef.current;
+    const target = getTargetElement(event);
+    const nestedTriggerHovered = detectNestedTriggerHover(target);
+    const triggerEl = triggerElementRef.current;
+    const targetInsideTrigger = triggerEl && target && (0, import_element.contains)(triggerEl, target);
+    if (nestedTriggerHovered && store.select("open") && store.select("lastOpenChangeReason") === import_createChangeEventDetails.REASONS.triggerHover) {
+      store.setOpen(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.triggerHover, event));
+      return;
+    }
+    if (wasNestedTriggerHovered && !nestedTriggerHovered && targetInsideTrigger && !disabledRef.current && !store.select("open") && triggerEl && // Match the hover hook's non-strict mouse fallback for mouse-only event sequences.
+    (0, import_event.isMouseLikePointerType)(pointerTypeRef.current)) {
+      const openTooltip = () => {
+        if (!isNestedTriggerHoveredRef.current && !disabledRef.current && !store.select("open")) {
+          store.setOpen(true, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.triggerHover, event, triggerEl));
+        }
+      };
+      const openDelay = getOpenDelay();
+      if (openDelay === 0) {
+        nestedTriggerOpenTimeout.clear();
+        openTooltip();
+      } else {
+        nestedTriggerOpenTimeout.start(openDelay, openTooltip);
+      }
+    }
+  }
+  const rootTriggerProps = store.useState(
+    "triggerProps",
+    (0, import_internal.subSlot)(slot, "tp"),
+    isMountedByThisTrigger
+  );
+  const shouldApplyRootTriggerProps = isMountedByThisTrigger || trackCursorAxis !== "none";
+  const state = { open: isOpenedByThisTrigger };
+  return (0, import_useRenderElement.useRenderElement)(
+    "button",
+    { render, className, style },
+    {
+      state,
+      ref: [ref, registerTrigger, triggerElementRef],
+      props: [
+        hoverProps,
+        focusProps,
+        shouldApplyRootTriggerProps ? rootTriggerProps : void 0,
+        {
+          onMouseOver(event) {
+            handleNestedTriggerHover(event);
+          },
+          onFocus(event) {
+            if (isEnabledNestedTriggerTarget(getTargetElement(event))) {
+              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);
+            }
+          },
+          onClick(event) {
+            if (closeOnClick && !store.select("open")) {
+              store.cancelPendingOpen(event);
+            }
+          },
+          id: thisTriggerId,
+          [TooltipTriggerDataAttributes.triggerDisabled]: disabled ? "" : void 0,
+          [TOOLTIP_TRIGGER_IDENTIFIER]: disabled ? void 0 : ""
+        },
+        elementProps
+      ],
+      stateAttributesMapping: import_popupStateMapping.triggerOpenStateMapping
+    },
+    (0, import_internal.subSlot)(slot, "re")
+  );
+}
+function TooltipPortal(props) {
+  const slot = (0, import_internal.S)("TooltipPortal");
+  const { keepMounted = false, ref, ...portalProps } = props;
+  const store = useTooltipRootContext();
+  const mounted = store.useState("mounted", (0, import_internal.subSlot)(slot, "mounted"));
+  if (!(mounted || keepMounted)) {
+    return null;
+  }
+  return (0, import_octane.createElement)(TooltipPortalContext.Provider, {
+    value: keepMounted,
+    children: (0, import_octane.createElement)(import_FloatingPortalLite.FloatingPortalLite, { ref, ...portalProps })
+  });
+}
+function TooltipPositioner(componentProps) {
+  const slot = (0, import_internal.S)("TooltipPositioner");
+  const {
+    render,
+    className,
+    style,
+    anchor,
+    positionMethod = "absolute",
+    side = "top",
+    align = "center",
+    sideOffset = 0,
+    alignOffset = 0,
+    collisionBoundary = "clipping-ancestors",
+    collisionPadding = 5,
+    arrowPadding = 5,
+    sticky = false,
+    disableAnchorTracking = false,
+    collisionAvoidance = import_constants.POPUP_COLLISION_AVOIDANCE,
+    ref,
+    ...elementProps
+  } = componentProps;
+  const store = useTooltipRootContext();
+  const keepMounted = useTooltipPortalContext();
+  const open = store.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const mounted = store.useState("mounted", (0, import_internal.subSlot)(slot, "mounted"));
+  const trackCursorAxis = store.useState("trackCursorAxis", (0, import_internal.subSlot)(slot, "tca"));
+  const disableHoverablePopup = store.useState("disableHoverablePopup", (0, import_internal.subSlot)(slot, "dhp"));
+  const floatingRootContext = store.useState("floatingRootContext", (0, import_internal.subSlot)(slot, "frc"));
+  const instantType = store.useState("instantType", (0, import_internal.subSlot)(slot, "instant"));
+  const transitionStatus = store.useState("transitionStatus", (0, import_internal.subSlot)(slot, "trans"));
+  const hasViewport = store.useState("hasViewport", (0, import_internal.subSlot)(slot, "viewport"));
+  const positioning = (0, import_useAnchorPositioning.useAnchorPositioning)(
+    {
+      anchor,
+      positionMethod,
+      floatingRootContext,
+      mounted,
+      side,
+      sideOffset,
+      align,
+      alignOffset,
+      collisionBoundary,
+      collisionPadding,
+      sticky,
+      arrowPadding,
+      disableAnchorTracking,
+      keepMounted,
+      collisionAvoidance,
+      adaptiveOrigin: hasViewport ? import_adaptiveOriginMiddleware.adaptiveOrigin : void 0
+    },
+    (0, import_internal.subSlot)(slot, "pos")
+  );
+  const state = (0, import_octane.useMemo)(
+    () => ({
+      open,
+      side: positioning.side,
+      align: positioning.align,
+      anchorHidden: positioning.anchorHidden,
+      instant: trackCursorAxis !== "none" ? "tracking-cursor" : instantType
+    }),
+    [
+      open,
+      positioning.side,
+      positioning.align,
+      positioning.anchorHidden,
+      trackCursorAxis,
+      instantType
+    ],
+    (0, import_internal.subSlot)(slot, "state")
+  );
+  const setPositionerElement = store.useStateSetter("positionerElement", (0, import_internal.subSlot)(slot, "spe"));
+  const element = (0, import_usePositioner.usePositioner)(
+    { render, className, style },
+    state,
+    {
+      styles: positioning.positionerStyles,
+      transitionStatus,
+      props: elementProps,
+      refs: [ref, setPositionerElement],
+      hidden: !mounted,
+      inert: !open || trackCursorAxis === "both" || disableHoverablePopup
+    },
+    (0, import_internal.subSlot)(slot, "positioner")
+  );
+  return (0, import_octane.createElement)(TooltipPositionerContext.Provider, {
+    value: positioning,
+    children: element
+  });
+}
+const popupStateAttributesMapping = {
+  ...import_popupStateMapping.popupStateMapping,
+  ...import_useTransitionStatus.transitionStatusMapping
+};
+function TooltipPopup(componentProps) {
+  const slot = (0, import_internal.S)("TooltipPopup");
+  const { render, className, style, ref, ...elementProps } = componentProps;
+  const store = useTooltipRootContext();
+  const { side, align } = useTooltipPositionerContext();
+  const open = store.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const instantType = store.useState("instantType", (0, import_internal.subSlot)(slot, "instant"));
+  const transitionStatus = store.useState("transitionStatus", (0, import_internal.subSlot)(slot, "trans"));
+  const popupProps = store.useState("popupProps", (0, import_internal.subSlot)(slot, "pp"));
+  const floatingContext = store.useState("floatingRootContext", (0, import_internal.subSlot)(slot, "frc"));
+  const disabled = store.useState("disabled", (0, import_internal.subSlot)(slot, "disabled"));
+  const closeDelay = store.useState("closeDelay", (0, import_internal.subSlot)(slot, "closeDelay"));
+  (0, import_useOpenChangeComplete.useOpenChangeComplete)(
+    {
+      open,
+      ref: store.context.popupRef,
+      onComplete() {
+        if (open) {
+          store.context.onOpenChangeComplete?.(true);
+        }
+      }
+    },
+    (0, import_internal.subSlot)(slot, "occ")
+  );
+  (0, import_useHoverFloatingInteraction.useHoverFloatingInteraction)(
+    floatingContext,
+    { enabled: !disabled, closeDelay },
+    (0, import_internal.subSlot)(slot, "hoverPopup")
+  );
+  const setPopupElement = store.useStateSetter("popupElement", (0, import_internal.subSlot)(slot, "spe"));
+  const state = { open, side, align, instant: instantType, transitionStatus };
+  return (0, import_useRenderElement.useRenderElement)(
+    "div",
+    { render, className, style },
+    {
+      state,
+      ref: [ref, store.context.popupRef, setPopupElement],
+      props: [popupProps, (0, import_getDisabledMountTransitionStyles.getDisabledMountTransitionStyles)(transitionStatus), elementProps],
+      stateAttributesMapping: popupStateAttributesMapping
+    },
+    (0, import_internal.subSlot)(slot, "re")
+  );
+}
+function TooltipArrow(componentProps) {
+  const slot = (0, import_internal.S)("TooltipArrow");
+  const { render, className, style, ref, ...elementProps } = componentProps;
+  const store = useTooltipRootContext();
+  const { arrowRef, side, align, arrowUncentered, arrowStyles } = useTooltipPositionerContext();
+  const open = store.useState("open", (0, import_internal.subSlot)(slot, "open"));
+  const instantType = store.useState("instantType", (0, import_internal.subSlot)(slot, "instant"));
+  const state = { open, side, align, uncentered: arrowUncentered, instant: instantType };
+  return (0, import_useRenderElement.useRenderElement)(
+    "div",
+    { render, className, style },
+    {
+      state,
+      ref: [ref, arrowRef],
+      props: [{ style: arrowStyles, "aria-hidden": true }, elementProps],
+      stateAttributesMapping: import_popupStateMapping.popupStateMapping
+    },
+    (0, import_internal.subSlot)(slot, "re")
+  );
+}
+const viewportStateAttributesMapping = {
+  activationDirection: (value) => value ? { "data-activation-direction": value } : null
+};
+function TooltipViewport(componentProps) {
+  const slot = (0, import_internal.S)("TooltipViewport");
+  const { render, className, style, children, ref, ...elementProps } = componentProps;
+  const store = useTooltipRootContext();
+  const positioner = useTooltipPositionerContext();
+  const instantType = store.useState("instantType", (0, import_internal.subSlot)(slot, "instant"));
+  const { children: childrenToRender, state: viewportState } = (0, import_usePopupViewport.usePopupViewport)(
+    { store, side: positioner.side, cssVars: TooltipViewportCssVars, children },
+    (0, import_internal.subSlot)(slot, "vp")
+  );
+  const state = {
+    activationDirection: viewportState.activationDirection,
+    transitioning: viewportState.transitioning,
+    instant: instantType
+  };
+  return (0, import_useRenderElement.useRenderElement)(
+    "div",
+    { render, className, style },
+    {
+      state,
+      ref,
+      props: [elementProps, { children: childrenToRender }],
+      stateAttributesMapping: viewportStateAttributesMapping
+    },
+    (0, import_internal.subSlot)(slot, "re")
+  );
+}
+const Tooltip = {
+  Provider: TooltipProvider,
+  Root: TooltipRoot,
+  Trigger: TooltipTrigger,
+  Portal: TooltipPortal,
+  Positioner: TooltipPositioner,
+  Popup: TooltipPopup,
+  Arrow: TooltipArrow,
+  Viewport: TooltipViewport,
+  createHandle: createTooltipHandle,
+  Handle: TooltipHandle
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OPEN_DELAY,
+  Tooltip,
+  TooltipHandle,
+  TooltipStore,
+  TooltipTriggerDataAttributes,
+  TooltipViewportCssVars,
+  createTooltipHandle,
+  useTooltipPositionerContext,
+  useTooltipRootContext
+});