lynote-ui 0.0.1

package/dist/tooltip/index.js

@@ -0,0 +1,940 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("../jsx-runtime-CPzt8Nmm.js");
+const React = require("react");
+const popupStateMapping = require("../popupStateMapping-DKN5mXrh.js");
+const useOnFirstRender = require("../useOnFirstRender-BYSeF6Y1.js");
+const useIsoLayoutEffect = require("../useIsoLayoutEffect-CYDr9Bko.js");
+const useRenderElement = require("../useRenderElement-CtyURhhF.js");
+const createBaseUIEventDetails = require("../createBaseUIEventDetails-D39y2D9R.js");
+const ReactDOM = require("react-dom");
+const useSyncedFloatingRootContext = require("../useSyncedFloatingRootContext-BhwJbN5C.js");
+const floatingUi_utils_dom = require("../floating-ui.utils.dom-djqmdyxg.js");
+const useStableCallback = require("../useStableCallback-CfE_knIO.js");
+const event = require("../event-BHxKjfyi.js");
+const element = require("../element-DAAyJrnp.js");
+const FloatingPortalLite = require("../FloatingPortalLite-CEKehtqV.js");
+const useAnchorPositioning = require("../useAnchorPositioning-jXRh4g8d.js");
+const useOpenChangeComplete = require("../useOpenChangeComplete-B0xZNwMu.js");
+const safePolygon = require("../safePolygon-DzT-LXP_.js");
+const utils = require("../utils-ij3i9zTT.js");
+const useTimeout = require("../useTimeout-CSlJ10_7.js");
+const useBaseUiId = require("../useBaseUiId-ZDgjliOe.js");
+const useFocus = require("../useFocus-BonLJ9UY.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+const ReactDOM__namespace = /* @__PURE__ */ _interopNamespaceDefault(ReactDOM);
+const FloatingDelayGroupContext = /* @__PURE__ */ React__namespace.createContext({
+  hasProvider: false,
+  timeoutMs: 0,
+  delayRef: {
+    current: 0
+  },
+  initialDelayRef: {
+    current: 0
+  },
+  timeout: new useTimeout.Timeout(),
+  currentIdRef: {
+    current: null
+  },
+  currentContextRef: {
+    current: null
+  }
+});
+if (process.env.NODE_ENV !== "production") FloatingDelayGroupContext.displayName = "FloatingDelayGroupContext";
+function FloatingDelayGroup(props) {
+  const {
+    children,
+    delay,
+    timeoutMs = 0
+  } = props;
+  const delayRef = React__namespace.useRef(delay);
+  const initialDelayRef = React__namespace.useRef(delay);
+  const currentIdRef = React__namespace.useRef(null);
+  const currentContextRef = React__namespace.useRef(null);
+  const timeout = useTimeout.useTimeout();
+  return /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(FloatingDelayGroupContext.Provider, {
+    value: React__namespace.useMemo(() => ({
+      hasProvider: true,
+      delayRef,
+      initialDelayRef,
+      currentIdRef,
+      timeoutMs,
+      currentContextRef,
+      timeout
+    }), [timeoutMs, timeout]),
+    children
+  });
+}
+function useDelayGroup(context, options = {
+  open: false
+}) {
+  const store = "rootStore" in context ? context.rootStore : context;
+  const floatingId = store.useState("floatingId");
+  const {
+    open
+  } = options;
+  const groupContext = React__namespace.useContext(FloatingDelayGroupContext);
+  const {
+    currentIdRef,
+    delayRef,
+    timeoutMs,
+    initialDelayRef,
+    currentContextRef,
+    hasProvider,
+    timeout
+  } = groupContext;
+  const [isInstantPhase, setIsInstantPhase] = React__namespace.useState(false);
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    function unset() {
+      var _a;
+      setIsInstantPhase(false);
+      (_a = currentContextRef.current) == null ? void 0 : _a.setIsInstantPhase(false);
+      currentIdRef.current = null;
+      currentContextRef.current = null;
+      delayRef.current = initialDelayRef.current;
+    }
+    if (!currentIdRef.current) {
+      return void 0;
+    }
+    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();
+    }
+    return void 0;
+  }, [open, floatingId, currentIdRef, delayRef, timeoutMs, initialDelayRef, currentContextRef, timeout, store]);
+  useIsoLayoutEffect.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: safePolygon.getDelay(initialDelayRef.current, "close")
+    };
+    if (prevId !== null && prevId !== floatingId) {
+      setIsInstantPhase(true);
+      prevContext == null ? void 0 : prevContext.setIsInstantPhase(true);
+      prevContext == null ? void 0 : prevContext.onOpenChange(false, createBaseUIEventDetails.createChangeEventDetails(createBaseUIEventDetails.none));
+    } else {
+      setIsInstantPhase(false);
+      prevContext == null ? void 0 : prevContext.setIsInstantPhase(false);
+    }
+  }, [open, floatingId, store, currentIdRef, delayRef, timeoutMs, initialDelayRef, currentContextRef, timeout]);
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    return () => {
+      currentContextRef.current = null;
+    };
+  }, [currentContextRef]);
+  return React__namespace.useMemo(() => ({
+    hasProvider,
+    delayRef,
+    isInstantPhase
+  }), [hasProvider, delayRef, isInstantPhase]);
+}
+function createVirtualElement(domElement, data) {
+  let offsetX = null;
+  let offsetY = null;
+  let isAutoUpdateEvent = false;
+  return {
+    contextElement: domElement || void 0,
+    getBoundingClientRect() {
+      var _a;
+      const domRect = (domElement == null ? void 0 : domElement.getBoundingClientRect()) || {
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+      };
+      const isXAxis = data.axis === "x" || data.axis === "both";
+      const isYAxis = data.axis === "y" || data.axis === "both";
+      const canTrackCursorOnAutoUpdate = ["mouseenter", "mousemove"].includes(((_a = data.dataRef.current.openEvent) == null ? void 0 : _a.type) || "") && data.pointerType !== "touch";
+      let width = domRect.width;
+      let height = domRect.height;
+      let x = domRect.x;
+      let y = domRect.y;
+      if (offsetX == null && data.x && isXAxis) {
+        offsetX = domRect.x - data.x;
+      }
+      if (offsetY == null && data.y && isYAxis) {
+        offsetY = domRect.y - data.y;
+      }
+      x -= offsetX || 0;
+      y -= offsetY || 0;
+      width = 0;
+      height = 0;
+      if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {
+        width = data.axis === "y" ? domRect.width : 0;
+        height = data.axis === "x" ? domRect.height : 0;
+        x = isXAxis && data.x != null ? data.x : x;
+        y = isYAxis && data.y != null ? data.y : y;
+      } else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {
+        height = data.axis === "x" ? domRect.height : height;
+        width = data.axis === "y" ? domRect.width : width;
+      }
+      isAutoUpdateEvent = true;
+      return {
+        width,
+        height,
+        x,
+        y,
+        top: y,
+        right: x + width,
+        bottom: y + height,
+        left: x
+      };
+    }
+  };
+}
+function isMouseBasedEvent(event2) {
+  return event2 != null && event2.clientX != null;
+}
+function useClientPoint(context, 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 {
+    enabled = true,
+    axis = "both"
+  } = props;
+  const initialRef = React__namespace.useRef(false);
+  const cleanupListenerRef = React__namespace.useRef(null);
+  const [pointerType, setPointerType] = React__namespace.useState();
+  const [reactive, setReactive] = React__namespace.useState([]);
+  const setReference = useStableCallback.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.useStableCallback((event2) => {
+    if (!open) {
+      setReference(event2.clientX, event2.clientY, event2.currentTarget);
+    } else if (!cleanupListenerRef.current) {
+      setReactive([]);
+    }
+  });
+  const openCheck = event.isMouseLikePointerType(pointerType) ? floating : open;
+  const addListener = React__namespace.useCallback(() => {
+    if (!openCheck || !enabled) {
+      return void 0;
+    }
+    const win = floatingUi_utils_dom.getWindow(floating);
+    function handleMouseMove(event2) {
+      const target = element.getTarget(event2);
+      if (!element.contains(floating, target)) {
+        setReference(event2.clientX, event2.clientY);
+      } else {
+        win.removeEventListener("mousemove", handleMouseMove);
+        cleanupListenerRef.current = null;
+      }
+    }
+    if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) {
+      win.addEventListener("mousemove", handleMouseMove);
+      const cleanup = () => {
+        win.removeEventListener("mousemove", handleMouseMove);
+        cleanupListenerRef.current = null;
+      };
+      cleanupListenerRef.current = cleanup;
+      return cleanup;
+    }
+    store.set("positionReference", domReference);
+    return void 0;
+  }, [openCheck, enabled, floating, dataRef, domReference, store, setReference]);
+  React__namespace.useEffect(() => {
+    return addListener();
+  }, [addListener, reactive]);
+  React__namespace.useEffect(() => {
+    if (enabled && !floating) {
+      initialRef.current = false;
+    }
+  }, [enabled, floating]);
+  React__namespace.useEffect(() => {
+    if (!enabled && open) {
+      initialRef.current = true;
+    }
+  }, [enabled, open]);
+  const reference = React__namespace.useMemo(() => {
+    function setPointerTypeRef(event2) {
+      setPointerType(event2.pointerType);
+    }
+    return {
+      onPointerDown: setPointerTypeRef,
+      onPointerEnter: setPointerTypeRef,
+      onMouseMove: handleReferenceEnterOrMove,
+      onMouseEnter: handleReferenceEnterOrMove
+    };
+  }, [handleReferenceEnterOrMove]);
+  return React__namespace.useMemo(() => enabled ? {
+    reference,
+    trigger: reference
+  } : {}, [enabled, reference]);
+}
+const TooltipRootContext = /* @__PURE__ */ React__namespace.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipRootContext.displayName = "TooltipRootContext";
+function useTooltipRootContext(optional) {
+  const context = React__namespace.useContext(TooltipRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>." : useRenderElement.formatErrorMessage(72));
+  }
+  return context;
+}
+const selectors = {
+  ...useSyncedFloatingRootContext.popupStoreSelectors,
+  disabled: popupStateMapping.createSelector((state) => state.disabled),
+  instantType: popupStateMapping.createSelector((state) => state.instantType),
+  isInstantPhase: popupStateMapping.createSelector((state) => state.isInstantPhase),
+  trackCursorAxis: popupStateMapping.createSelector((state) => state.trackCursorAxis),
+  disableHoverablePopup: popupStateMapping.createSelector((state) => state.disableHoverablePopup),
+  lastOpenChangeReason: popupStateMapping.createSelector((state) => state.openChangeReason),
+  closeOnClick: popupStateMapping.createSelector((state) => state.closeOnClick),
+  closeDelay: popupStateMapping.createSelector((state) => state.closeDelay),
+  hasViewport: popupStateMapping.createSelector((state) => state.hasViewport)
+};
+class TooltipStore extends popupStateMapping.ReactStore {
+  constructor(initialState) {
+    super({
+      ...createInitialState(),
+      ...initialState
+    }, {
+      popupRef: /* @__PURE__ */ React__namespace.createRef(),
+      onOpenChange: void 0,
+      onOpenChangeComplete: void 0,
+      triggerElements: new popupStateMapping.PopupTriggerMap()
+    }, selectors);
+    __publicField(this, "setOpen", (nextOpen, eventDetails) => {
+      var _a, _b;
+      const reason = eventDetails.reason;
+      const isHover = reason === createBaseUIEventDetails.triggerHover;
+      const isFocusOpen = nextOpen && reason === createBaseUIEventDetails.triggerFocus;
+      const isDismissClose = !nextOpen && (reason === createBaseUIEventDetails.triggerPress || reason === createBaseUIEventDetails.escapeKey);
+      eventDetails.preventUnmountOnClose = () => {
+        this.set("preventUnmountingOnClose", true);
+      };
+      (_b = (_a = this.context).onOpenChange) == null ? void 0 : _b.call(_a, nextOpen, eventDetails);
+      if (eventDetails.isCanceled) {
+        return;
+      }
+      const changeState = () => {
+        var _a2;
+        const updatedState = {
+          open: nextOpen,
+          openChangeReason: reason
+        };
+        if (isFocusOpen) {
+          updatedState.instantType = "focus";
+        } else if (isDismissClose) {
+          updatedState.instantType = "dismiss";
+        } else if (reason === createBaseUIEventDetails.triggerHover) {
+          updatedState.instantType = void 0;
+        }
+        const newTriggerId = ((_a2 = eventDetails.trigger) == null ? void 0 : _a2.id) ?? null;
+        if (newTriggerId || nextOpen) {
+          updatedState.activeTriggerId = newTriggerId;
+          updatedState.activeTriggerElement = eventDetails.trigger ?? null;
+        }
+        this.update(updatedState);
+      };
+      if (isHover) {
+        ReactDOM__namespace.flushSync(changeState);
+      } else {
+        changeState();
+      }
+    });
+  }
+  static useStore(externalStore, initialState) {
+    const internalStore = useRenderElement.useRefWithInit(() => {
+      return new TooltipStore(initialState);
+    }).current;
+    const store = externalStore ?? internalStore;
+    const floatingRootContext = useSyncedFloatingRootContext.useSyncedFloatingRootContext({
+      popupStore: store,
+      onOpenChange: store.setOpen
+    });
+    store.state.floatingRootContext = floatingRootContext;
+    return store;
+  }
+}
+function createInitialState() {
+  return {
+    ...useSyncedFloatingRootContext.createInitialPopupStoreState(),
+    disabled: false,
+    instantType: void 0,
+    isInstantPhase: false,
+    trackCursorAxis: "none",
+    disableHoverablePopup: false,
+    openChangeReason: null,
+    closeOnClick: true,
+    closeDelay: 0,
+    hasViewport: false
+  };
+}
+const TooltipRoot = popupStateMapping.fastComponent(function TooltipRoot2(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 == null ? void 0 : handle.store, {
+    open: defaultOpen,
+    openProp,
+    activeTriggerId: defaultTriggerIdProp,
+    triggerIdProp
+  });
+  useOnFirstRender.useOnFirstRender(() => {
+    if (openProp === void 0 && store.state.open === false && defaultOpen === true) {
+      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 payload = store.useState("payload");
+  store.useSyncedValues({
+    trackCursorAxis,
+    disableHoverablePopup
+  });
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    if (openState && disabled) {
+      store.setOpen(false, createBaseUIEventDetails.createChangeEventDetails(createBaseUIEventDetails.disabled));
+    }
+  }, [openState, disabled, store]);
+  store.useSyncedValue("disabled", disabled);
+  useSyncedFloatingRootContext.useImplicitActiveTrigger(store);
+  const {
+    forceUnmount,
+    transitionStatus
+  } = useSyncedFloatingRootContext.useOpenStateTransitions(open, store);
+  const isInstantPhase = store.useState("isInstantPhase");
+  const instantType = store.useState("instantType");
+  const lastOpenChangeReason = store.useState("lastOpenChangeReason");
+  const previousInstantTypeRef = React__namespace.useRef(null);
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    if (transitionStatus === "ending" && lastOpenChangeReason === createBaseUIEventDetails.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]);
+  useIsoLayoutEffect.useIsoLayoutEffect(() => {
+    if (open) {
+      if (activeTriggerId == null) {
+        store.set("payload", void 0);
+      }
+    }
+  }, [store, activeTriggerId, open]);
+  const handleImperativeClose = React__namespace.useCallback(() => {
+    store.setOpen(false, createTooltipEventDetails(store, createBaseUIEventDetails.imperativeAction));
+  }, [store]);
+  React__namespace.useImperativeHandle(actionsRef, () => ({
+    unmount: forceUnmount,
+    close: handleImperativeClose
+  }), [forceUnmount, handleImperativeClose]);
+  const floatingRootContext = store.useState("floatingRootContext");
+  const dismiss = popupStateMapping.useDismiss(floatingRootContext, {
+    enabled: !disabled,
+    referencePress: () => store.select("closeOnClick")
+  });
+  const clientPoint = useClientPoint(floatingRootContext, {
+    enabled: !disabled && trackCursorAxis !== "none",
+    axis: trackCursorAxis === "none" ? void 0 : trackCursorAxis
+  });
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getTriggerProps
+  } = popupStateMapping.useInteractions([dismiss, clientPoint]);
+  const activeTriggerProps = React__namespace.useMemo(() => getReferenceProps(), [getReferenceProps]);
+  const inactiveTriggerProps = React__namespace.useMemo(() => getTriggerProps(), [getTriggerProps]);
+  const popupProps = React__namespace.useMemo(() => getFloatingProps(), [getFloatingProps]);
+  store.useSyncedValues({
+    activeTriggerProps,
+    inactiveTriggerProps,
+    popupProps
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(TooltipRootContext.Provider, {
+    value: store,
+    children: typeof children === "function" ? children({
+      payload
+    }) : children
+  });
+});
+if (process.env.NODE_ENV !== "production") TooltipRoot.displayName = "TooltipRoot";
+function createTooltipEventDetails(store, reason) {
+  const details = createBaseUIEventDetails.createChangeEventDetails(reason);
+  details.preventUnmountOnClose = () => {
+    store.set("preventUnmountingOnClose", true);
+  };
+  return details;
+}
+const TooltipProviderContext = /* @__PURE__ */ React__namespace.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipProviderContext.displayName = "TooltipProviderContext";
+function useTooltipProviderContext() {
+  return React__namespace.useContext(TooltipProviderContext);
+}
+let TooltipTriggerDataAttributes = (function(TooltipTriggerDataAttributes2) {
+  TooltipTriggerDataAttributes2[TooltipTriggerDataAttributes2["popupOpen"] = popupStateMapping.CommonTriggerDataAttributes.popupOpen] = "popupOpen";
+  TooltipTriggerDataAttributes2["triggerDisabled"] = "data-trigger-disabled";
+  return TooltipTriggerDataAttributes2;
+})({});
+const OPEN_DELAY = 600;
+const TooltipTrigger$1 = popupStateMapping.fastComponentRef(function TooltipTrigger(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    handle,
+    payload,
+    disabled: disabledProp,
+    delay,
+    closeOnClick = true,
+    closeDelay,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const rootContext = useTooltipRootContext(true);
+  const store = (handle == null ? void 0 : handle.store) ?? rootContext;
+  if (!store) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle." : useRenderElement.formatErrorMessage(82));
+  }
+  const thisTriggerId = useBaseUiId.useBaseUiId(idProp);
+  const isTriggerActive = store.useState("isTriggerActive", thisTriggerId);
+  const isOpenedByThisTrigger = store.useState("isOpenedByTrigger", thisTriggerId);
+  const floatingRootContext = store.useState("floatingRootContext");
+  const triggerElementRef = React__namespace.useRef(null);
+  const delayWithDefault = delay ?? OPEN_DELAY;
+  const closeDelayWithDefault = closeDelay ?? 0;
+  const {
+    registerTrigger,
+    isMountedByThisTrigger
+  } = useSyncedFloatingRootContext.useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+    payload,
+    closeOnClick,
+    closeDelay: closeDelayWithDefault
+  });
+  const providerContext = useTooltipProviderContext();
+  const {
+    delayRef,
+    isInstantPhase,
+    hasProvider
+  } = useDelayGroup(floatingRootContext, {
+    open: isOpenedByThisTrigger
+  });
+  store.useSyncedValue("isInstantPhase", isInstantPhase);
+  const rootDisabled = store.useState("disabled");
+  const disabled = disabledProp ?? rootDisabled;
+  const trackCursorAxis = store.useState("trackCursorAxis");
+  const disableHoverablePopup = store.useState("disableHoverablePopup");
+  const hoverProps = safePolygon.useHoverReferenceInteraction(floatingRootContext, {
+    enabled: !disabled,
+    mouseOnly: true,
+    move: false,
+    handleClose: !disableHoverablePopup && trackCursorAxis !== "both" ? safePolygon.safePolygon() : null,
+    restMs() {
+      const providerDelay = providerContext == null ? void 0 : providerContext.delay;
+      const groupOpenValue = typeof delayRef.current === "object" ? delayRef.current.open : void 0;
+      let computedRestMs = delayWithDefault;
+      if (hasProvider) {
+        if (groupOpenValue !== 0) {
+          computedRestMs = delay ?? providerDelay ?? delayWithDefault;
+        } else {
+          computedRestMs = 0;
+        }
+      }
+      return computedRestMs;
+    },
+    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
+  });
+  const focusProps = useFocus.useFocus(floatingRootContext, {
+    enabled: !disabled
+  }).reference;
+  const state = {
+    open: isOpenedByThisTrigger
+  };
+  const rootTriggerProps = store.useState("triggerProps", isMountedByThisTrigger);
+  const element2 = useRenderElement.useRenderElement("button", componentProps, {
+    state,
+    ref: [forwardedRef, registerTrigger, triggerElementRef],
+    props: [hoverProps, focusProps, rootTriggerProps, {
+      onPointerDown() {
+        store.set("closeOnClick", closeOnClick);
+      },
+      id: thisTriggerId,
+      [TooltipTriggerDataAttributes.triggerDisabled]: disabled ? "" : void 0
+    }, elementProps],
+    stateAttributesMapping: popupStateMapping.triggerOpenStateMapping
+  });
+  return element2;
+});
+if (process.env.NODE_ENV !== "production") TooltipTrigger$1.displayName = "TooltipTrigger";
+const TooltipPortalContext = /* @__PURE__ */ React__namespace.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipPortalContext.displayName = "TooltipPortalContext";
+function useTooltipPortalContext() {
+  const value = React__namespace.useContext(TooltipPortalContext);
+  if (value === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Portal> is missing." : useRenderElement.formatErrorMessage(70));
+  }
+  return value;
+}
+const TooltipPortal = /* @__PURE__ */ React__namespace.forwardRef(function TooltipPortal2(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__ */ jsxRuntime.jsxRuntimeExports.jsx(TooltipPortalContext.Provider, {
+    value: keepMounted,
+    children: /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(FloatingPortalLite.FloatingPortalLite, {
+      ref: forwardedRef,
+      ...portalProps
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") TooltipPortal.displayName = "TooltipPortal";
+const TooltipPositionerContext = /* @__PURE__ */ React__namespace.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipPositionerContext.displayName = "TooltipPositionerContext";
+function useTooltipPositionerContext() {
+  const context = React__namespace.useContext(TooltipPositionerContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>." : useRenderElement.formatErrorMessage(71));
+  }
+  return context;
+}
+const TooltipPositioner = /* @__PURE__ */ React__namespace.forwardRef(function TooltipPositioner2(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 = popupStateMapping.POPUP_COLLISION_AVOIDANCE,
+    ...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.useAnchorPositioning({
+    anchor,
+    positionMethod,
+    floatingRootContext,
+    mounted,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    arrowPadding,
+    disableAnchorTracking,
+    keepMounted,
+    collisionAvoidance,
+    adaptiveOrigin: hasViewport ? useAnchorPositioning.adaptiveOrigin : void 0
+  });
+  const defaultProps = React__namespace.useMemo(() => {
+    const hiddenStyles = {};
+    if (!open || trackCursorAxis === "both" || disableHoverablePopup) {
+      hiddenStyles.pointerEvents = "none";
+    }
+    return {
+      role: "presentation",
+      hidden: !mounted,
+      style: {
+        ...positioning.positionerStyles,
+        ...hiddenStyles
+      }
+    };
+  }, [open, trackCursorAxis, disableHoverablePopup, mounted, positioning.positionerStyles]);
+  const state = React__namespace.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]);
+  const contextValue = React__namespace.useMemo(() => ({
+    ...state,
+    arrowRef: positioning.arrowRef,
+    arrowStyles: positioning.arrowStyles,
+    arrowUncentered: positioning.arrowUncentered
+  }), [state, positioning.arrowRef, positioning.arrowStyles, positioning.arrowUncentered]);
+  const element2 = useRenderElement.useRenderElement("div", componentProps, {
+    state,
+    props: [defaultProps, useAnchorPositioning.getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    ref: [forwardedRef, store.useStateSetter("positionerElement")],
+    stateAttributesMapping: popupStateMapping.popupStateMapping
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(TooltipPositionerContext.Provider, {
+    value: contextValue,
+    children: element2
+  });
+});
+if (process.env.NODE_ENV !== "production") TooltipPositioner.displayName = "TooltipPositioner";
+const stateAttributesMapping = {
+  ...popupStateMapping.popupStateMapping,
+  ...useOpenChangeComplete.transitionStatusMapping
+};
+const TooltipPopup = /* @__PURE__ */ React__namespace.forwardRef(function TooltipPopup2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    ...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");
+  useOpenChangeComplete.useOpenChangeComplete({
+    open,
+    ref: store.context.popupRef,
+    onComplete() {
+      var _a, _b;
+      if (open) {
+        (_b = (_a = store.context).onOpenChangeComplete) == null ? void 0 : _b.call(_a, true);
+      }
+    }
+  });
+  const disabled = store.useState("disabled");
+  const closeDelay = store.useState("closeDelay");
+  safePolygon.useHoverFloatingInteraction(floatingContext, {
+    enabled: !disabled,
+    closeDelay
+  });
+  const state = {
+    open,
+    side,
+    align,
+    instant: instantType,
+    transitionStatus
+  };
+  const element2 = useRenderElement.useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, store.context.popupRef, store.useStateSetter("popupElement")],
+    props: [popupProps, useAnchorPositioning.getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    stateAttributesMapping
+  });
+  return element2;
+});
+if (process.env.NODE_ENV !== "production") TooltipPopup.displayName = "TooltipPopup";
+const TooltipArrow = /* @__PURE__ */ React__namespace.forwardRef(function TooltipArrow2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    ...elementProps
+  } = componentProps;
+  const store = useTooltipRootContext();
+  const instantType = store.useState("instantType");
+  const {
+    open,
+    arrowRef,
+    side,
+    align,
+    arrowUncentered,
+    arrowStyles
+  } = useTooltipPositionerContext();
+  const state = {
+    open,
+    side,
+    align,
+    uncentered: arrowUncentered,
+    instant: instantType
+  };
+  const element2 = useRenderElement.useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, arrowRef],
+    props: [{
+      style: arrowStyles,
+      "aria-hidden": true
+    }, elementProps],
+    stateAttributesMapping: popupStateMapping.popupStateMapping
+  });
+  return element2;
+});
+if (process.env.NODE_ENV !== "production") TooltipArrow.displayName = "TooltipArrow";
+const TooltipProvider$1 = function TooltipProvider(props) {
+  const {
+    delay,
+    closeDelay,
+    timeout = 400
+  } = props;
+  const contextValue = React__namespace.useMemo(() => ({
+    delay,
+    closeDelay
+  }), [delay, closeDelay]);
+  const delayValue = React__namespace.useMemo(() => ({
+    open: delay,
+    close: closeDelay
+  }), [delay, closeDelay]);
+  return /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(TooltipProviderContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(FloatingDelayGroup, {
+      delay: delayValue,
+      timeoutMs: timeout,
+      children: props.children
+    })
+  });
+};
+if (process.env.NODE_ENV !== "production") TooltipProvider$1.displayName = "TooltipProvider";
+function TooltipProvider2({
+  delay = 0,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(
+    TooltipProvider$1,
+    {
+      "data-slot": "tooltip-provider",
+      delay,
+      ...props
+    }
+  );
+}
+function Tooltip({ ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(TooltipRoot, { "data-slot": "tooltip", ...props });
+}
+function TooltipTrigger2({ ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(TooltipTrigger$1, { "data-slot": "tooltip-trigger", ...props });
+}
+function TooltipContent({
+  className,
+  side = "top",
+  sideOffset = 4,
+  align = "center",
+  alignOffset = 0,
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(TooltipPortal, { children: /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(
+    TooltipPositioner,
+    {
+      align,
+      alignOffset,
+      side,
+      sideOffset,
+      className: "isolate z-50",
+      children: /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsxs(
+        TooltipPopup,
+        {
+          "data-slot": "tooltip-content",
+          className: utils.cn(
+            "z-50 inline-flex w-fit max-w-xs origin-(--transform-origin) items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs text-background has-data-[slot=kbd]:pr-1.5 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+            className
+          ),
+          ...props,
+          children: [
+            children,
+            /* @__PURE__ */ jsxRuntime.jsxRuntimeExports.jsx(TooltipArrow, { className: "z-50 size-2.5 translate-y-[calc(-50%-2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground data-[side=bottom]:top-1 data-[side=inline-end]:top-1/2! data-[side=inline-end]:-left-1 data-[side=inline-end]:-translate-y-1/2 data-[side=inline-start]:top-1/2! data-[side=inline-start]:-right-1 data-[side=inline-start]:-translate-y-1/2 data-[side=left]:top-1/2! data-[side=left]:-right-1 data-[side=left]:-translate-y-1/2 data-[side=right]:top-1/2! data-[side=right]:-left-1 data-[side=right]:-translate-y-1/2 data-[side=top]:-bottom-2.5" })
+          ]
+        }
+      )
+    }
+  ) });
+}
+exports.Tooltip = Tooltip;
+exports.TooltipContent = TooltipContent;
+exports.TooltipProvider = TooltipProvider2;
+exports.TooltipTrigger = TooltipTrigger2;
+//# sourceMappingURL=index.js.map