lynote-ui 0.0.1

package/dist/tooltip/index.mjs

@@ -0,0 +1,922 @@
+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);
+import { j as jsxRuntimeExports } from "../jsx-runtime-Dog7MAYX.mjs";
+import * as React from "react";
+import { R as ReactStore, P as PopupTriggerMap, q as createSelector, J as fastComponent, A as useDismiss, i as useInteractions, K as CommonTriggerDataAttributes, g as fastComponentRef, B as triggerOpenStateMapping, E as POPUP_COLLISION_AVOIDANCE, G as popupStateMapping } from "../popupStateMapping-Dvf6vjid.mjs";
+import { u as useOnFirstRender } from "../useOnFirstRender-_PvKQsmi.mjs";
+import { u as useIsoLayoutEffect } from "../useIsoLayoutEffect-CAx-dEZM.mjs";
+import { f as formatErrorMessage, a as useRefWithInit, u as useRenderElement } from "../useRenderElement-DtkRtCHE.mjs";
+import { c as createChangeEventDetails, n as none, d as triggerHover, a as triggerFocus, t as triggerPress, e as escapeKey, h as disabled, i as imperativeAction } from "../createBaseUIEventDetails-CRQSf9K3.mjs";
+import * as ReactDOM from "react-dom";
+import { p as popupStoreSelectors, a as useSyncedFloatingRootContext, c as createInitialPopupStoreState, b as useImplicitActiveTrigger, d as useOpenStateTransitions, u as useTriggerDataForwarding } from "../useSyncedFloatingRootContext-BiC-l-Yp.mjs";
+import { g as getWindow } from "../floating-ui.utils.dom-BAD07kLX.mjs";
+import { u as useStableCallback } from "../useStableCallback-8_xI9oDo.mjs";
+import { i as isMouseLikePointerType } from "../event-CcyVszlp.mjs";
+import { d as getTarget, c as contains } from "../element-BtC-M4rb.mjs";
+import { F as FloatingPortalLite } from "../FloatingPortalLite-CsPfJ360.mjs";
+import { u as useAnchorPositioning, a as adaptiveOrigin, g as getDisabledMountTransitionStyles } from "../useAnchorPositioning-DEkPt210.mjs";
+import { a as useOpenChangeComplete, t as transitionStatusMapping } from "../useOpenChangeComplete-DbPLu-k9.mjs";
+import { g as getDelay, u as useHoverReferenceInteraction, s as safePolygon, a as useHoverFloatingInteraction } from "../safePolygon-ClN7sX4N.mjs";
+import { c as cn } from "../utils-H80jjgLf.mjs";
+import { u as useTimeout, T as Timeout } from "../useTimeout-DP0d-UkF.mjs";
+import { u as useBaseUiId } from "../useBaseUiId-Dd6rCWZj.mjs";
+import { u as useFocus } from "../useFocus-D2m1G1R7.mjs";
+const FloatingDelayGroupContext = /* @__PURE__ */ React.createContext({
+  hasProvider: false,
+  timeoutMs: 0,
+  delayRef: {
+    current: 0
+  },
+  initialDelayRef: {
+    current: 0
+  },
+  timeout: new 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.useRef(delay);
+  const initialDelayRef = React.useRef(delay);
+  const currentIdRef = React.useRef(null);
+  const currentContextRef = React.useRef(null);
+  const timeout = useTimeout();
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(FloatingDelayGroupContext.Provider, {
+    value: React.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.useContext(FloatingDelayGroupContext);
+  const {
+    currentIdRef,
+    delayRef,
+    timeoutMs,
+    initialDelayRef,
+    currentContextRef,
+    hasProvider,
+    timeout
+  } = groupContext;
+  const [isInstantPhase, setIsInstantPhase] = React.useState(false);
+  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(() => {
+    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 (prevId !== null && prevId !== floatingId) {
+      setIsInstantPhase(true);
+      prevContext == null ? void 0 : prevContext.setIsInstantPhase(true);
+      prevContext == null ? void 0 : prevContext.onOpenChange(false, createChangeEventDetails(none));
+    } else {
+      setIsInstantPhase(false);
+      prevContext == null ? void 0 : prevContext.setIsInstantPhase(false);
+    }
+  }, [open, floatingId, store, currentIdRef, delayRef, timeoutMs, initialDelayRef, currentContextRef, timeout]);
+  useIsoLayoutEffect(() => {
+    return () => {
+      currentContextRef.current = null;
+    };
+  }, [currentContextRef]);
+  return React.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(event) {
+  return event != null && event.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.useRef(false);
+  const cleanupListenerRef = React.useRef(null);
+  const [pointerType, setPointerType] = React.useState();
+  const [reactive, setReactive] = React.useState([]);
+  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) {
+      setReference(event.clientX, event.clientY, event.currentTarget);
+    } else if (!cleanupListenerRef.current) {
+      setReactive([]);
+    }
+  });
+  const openCheck = isMouseLikePointerType(pointerType) ? floating : open;
+  const addListener = React.useCallback(() => {
+    if (!openCheck || !enabled) {
+      return void 0;
+    }
+    const win = getWindow(floating);
+    function handleMouseMove(event) {
+      const target = getTarget(event);
+      if (!contains(floating, target)) {
+        setReference(event.clientX, event.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.useEffect(() => {
+    return addListener();
+  }, [addListener, reactive]);
+  React.useEffect(() => {
+    if (enabled && !floating) {
+      initialRef.current = false;
+    }
+  }, [enabled, floating]);
+  React.useEffect(() => {
+    if (!enabled && open) {
+      initialRef.current = true;
+    }
+  }, [enabled, open]);
+  const reference = React.useMemo(() => {
+    function setPointerTypeRef(event) {
+      setPointerType(event.pointerType);
+    }
+    return {
+      onPointerDown: setPointerTypeRef,
+      onPointerEnter: setPointerTypeRef,
+      onMouseMove: handleReferenceEnterOrMove,
+      onMouseEnter: handleReferenceEnterOrMove
+    };
+  }, [handleReferenceEnterOrMove]);
+  return React.useMemo(() => enabled ? {
+    reference,
+    trigger: reference
+  } : {}, [enabled, reference]);
+}
+const TooltipRootContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipRootContext.displayName = "TooltipRootContext";
+function useTooltipRootContext(optional) {
+  const context = React.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>." : formatErrorMessage(72));
+  }
+  return context;
+}
+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) {
+    super({
+      ...createInitialState(),
+      ...initialState
+    }, {
+      popupRef: /* @__PURE__ */ React.createRef(),
+      onOpenChange: void 0,
+      onOpenChangeComplete: void 0,
+      triggerElements: new PopupTriggerMap()
+    }, selectors);
+    __publicField(this, "setOpen", (nextOpen, eventDetails) => {
+      var _a, _b;
+      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);
+      };
+      (_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 === 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.flushSync(changeState);
+      } else {
+        changeState();
+      }
+    });
+  }
+  static useStore(externalStore, initialState) {
+    const internalStore = useRefWithInit(() => {
+      return new TooltipStore(initialState);
+    }).current;
+    const store = externalStore ?? internalStore;
+    const floatingRootContext = useSyncedFloatingRootContext({
+      popupStore: store,
+      onOpenChange: store.setOpen
+    });
+    store.state.floatingRootContext = floatingRootContext;
+    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 = fastComponent(function TooltipRoot2(props) {
+  const {
+    disabled: disabled$1 = 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(() => {
+    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$1 && openState;
+  const activeTriggerId = store.useState("activeTriggerId");
+  const payload = store.useState("payload");
+  store.useSyncedValues({
+    trackCursorAxis,
+    disableHoverablePopup
+  });
+  useIsoLayoutEffect(() => {
+    if (openState && disabled$1) {
+      store.setOpen(false, createChangeEventDetails(disabled));
+    }
+  }, [openState, disabled$1, store]);
+  store.useSyncedValue("disabled", disabled$1);
+  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 = React.useRef(null);
+  useIsoLayoutEffect(() => {
+    if (transitionStatus === "ending" && lastOpenChangeReason === 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(() => {
+    if (open) {
+      if (activeTriggerId == null) {
+        store.set("payload", void 0);
+      }
+    }
+  }, [store, activeTriggerId, open]);
+  const handleImperativeClose = React.useCallback(() => {
+    store.setOpen(false, createTooltipEventDetails(store, imperativeAction));
+  }, [store]);
+  React.useImperativeHandle(actionsRef, () => ({
+    unmount: forceUnmount,
+    close: handleImperativeClose
+  }), [forceUnmount, handleImperativeClose]);
+  const floatingRootContext = store.useState("floatingRootContext");
+  const dismiss = useDismiss(floatingRootContext, {
+    enabled: !disabled$1,
+    referencePress: () => store.select("closeOnClick")
+  });
+  const clientPoint = useClientPoint(floatingRootContext, {
+    enabled: !disabled$1 && trackCursorAxis !== "none",
+    axis: trackCursorAxis === "none" ? void 0 : trackCursorAxis
+  });
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getTriggerProps
+  } = useInteractions([dismiss, clientPoint]);
+  const activeTriggerProps = React.useMemo(() => getReferenceProps(), [getReferenceProps]);
+  const inactiveTriggerProps = React.useMemo(() => getTriggerProps(), [getTriggerProps]);
+  const popupProps = React.useMemo(() => getFloatingProps(), [getFloatingProps]);
+  store.useSyncedValues({
+    activeTriggerProps,
+    inactiveTriggerProps,
+    popupProps
+  });
+  return /* @__PURE__ */ 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 = createChangeEventDetails(reason);
+  details.preventUnmountOnClose = () => {
+    store.set("preventUnmountingOnClose", true);
+  };
+  return details;
+}
+const TooltipProviderContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipProviderContext.displayName = "TooltipProviderContext";
+function useTooltipProviderContext() {
+  return React.useContext(TooltipProviderContext);
+}
+let TooltipTriggerDataAttributes = (function(TooltipTriggerDataAttributes2) {
+  TooltipTriggerDataAttributes2[TooltipTriggerDataAttributes2["popupOpen"] = CommonTriggerDataAttributes.popupOpen] = "popupOpen";
+  TooltipTriggerDataAttributes2["triggerDisabled"] = "data-trigger-disabled";
+  return TooltipTriggerDataAttributes2;
+})({});
+const OPEN_DELAY = 600;
+const TooltipTrigger$1 = 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." : 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 = React.useRef(null);
+  const delayWithDefault = delay ?? OPEN_DELAY;
+  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
+  });
+  store.useSyncedValue("isInstantPhase", isInstantPhase);
+  const rootDisabled = store.useState("disabled");
+  const disabled2 = disabledProp ?? rootDisabled;
+  const trackCursorAxis = store.useState("trackCursorAxis");
+  const disableHoverablePopup = store.useState("disableHoverablePopup");
+  const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
+    enabled: !disabled2,
+    mouseOnly: true,
+    move: false,
+    handleClose: !disableHoverablePopup && trackCursorAxis !== "both" ? 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(floatingRootContext, {
+    enabled: !disabled2
+  }).reference;
+  const state = {
+    open: isOpenedByThisTrigger
+  };
+  const rootTriggerProps = store.useState("triggerProps", isMountedByThisTrigger);
+  const element = useRenderElement("button", componentProps, {
+    state,
+    ref: [forwardedRef, registerTrigger, triggerElementRef],
+    props: [hoverProps, focusProps, rootTriggerProps, {
+      onPointerDown() {
+        store.set("closeOnClick", closeOnClick);
+      },
+      id: thisTriggerId,
+      [TooltipTriggerDataAttributes.triggerDisabled]: disabled2 ? "" : void 0
+    }, elementProps],
+    stateAttributesMapping: triggerOpenStateMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") TooltipTrigger$1.displayName = "TooltipTrigger";
+const TooltipPortalContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipPortalContext.displayName = "TooltipPortalContext";
+function useTooltipPortalContext() {
+  const value = React.useContext(TooltipPortalContext);
+  if (value === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Portal> is missing." : formatErrorMessage(70));
+  }
+  return value;
+}
+const TooltipPortal = /* @__PURE__ */ React.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__ */ jsxRuntimeExports.jsx(TooltipPortalContext.Provider, {
+    value: keepMounted,
+    children: /* @__PURE__ */ jsxRuntimeExports.jsx(FloatingPortalLite, {
+      ref: forwardedRef,
+      ...portalProps
+    })
+  });
+});
+if (process.env.NODE_ENV !== "production") TooltipPortal.displayName = "TooltipPortal";
+const TooltipPositionerContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") TooltipPositionerContext.displayName = "TooltipPositionerContext";
+function useTooltipPositionerContext() {
+  const context = React.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>." : formatErrorMessage(71));
+  }
+  return context;
+}
+const TooltipPositioner = /* @__PURE__ */ React.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 = 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({
+    anchor,
+    positionMethod,
+    floatingRootContext,
+    mounted,
+    side,
+    sideOffset,
+    align,
+    alignOffset,
+    collisionBoundary,
+    collisionPadding,
+    sticky,
+    arrowPadding,
+    disableAnchorTracking,
+    keepMounted,
+    collisionAvoidance,
+    adaptiveOrigin: hasViewport ? adaptiveOrigin : void 0
+  });
+  const defaultProps = React.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.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.useMemo(() => ({
+    ...state,
+    arrowRef: positioning.arrowRef,
+    arrowStyles: positioning.arrowStyles,
+    arrowUncentered: positioning.arrowUncentered
+  }), [state, positioning.arrowRef, positioning.arrowStyles, positioning.arrowUncentered]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    props: [defaultProps, getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    ref: [forwardedRef, store.useStateSetter("positionerElement")],
+    stateAttributesMapping: popupStateMapping
+  });
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(TooltipPositionerContext.Provider, {
+    value: contextValue,
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") TooltipPositioner.displayName = "TooltipPositioner";
+const stateAttributesMapping = {
+  ...popupStateMapping,
+  ...transitionStatusMapping
+};
+const TooltipPopup = /* @__PURE__ */ React.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({
+    open,
+    ref: store.context.popupRef,
+    onComplete() {
+      var _a, _b;
+      if (open) {
+        (_b = (_a = store.context).onOpenChangeComplete) == null ? void 0 : _b.call(_a, true);
+      }
+    }
+  });
+  const disabled2 = store.useState("disabled");
+  const closeDelay = store.useState("closeDelay");
+  useHoverFloatingInteraction(floatingContext, {
+    enabled: !disabled2,
+    closeDelay
+  });
+  const state = {
+    open,
+    side,
+    align,
+    instant: instantType,
+    transitionStatus
+  };
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, store.context.popupRef, store.useStateSetter("popupElement")],
+    props: [popupProps, getDisabledMountTransitionStyles(transitionStatus), elementProps],
+    stateAttributesMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") TooltipPopup.displayName = "TooltipPopup";
+const TooltipArrow = /* @__PURE__ */ React.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 element = useRenderElement("div", componentProps, {
+    state,
+    ref: [forwardedRef, arrowRef],
+    props: [{
+      style: arrowStyles,
+      "aria-hidden": true
+    }, elementProps],
+    stateAttributesMapping: popupStateMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") TooltipArrow.displayName = "TooltipArrow";
+const TooltipProvider$1 = function TooltipProvider(props) {
+  const {
+    delay,
+    closeDelay,
+    timeout = 400
+  } = props;
+  const contextValue = React.useMemo(() => ({
+    delay,
+    closeDelay
+  }), [delay, closeDelay]);
+  const delayValue = React.useMemo(() => ({
+    open: delay,
+    close: closeDelay
+  }), [delay, closeDelay]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(TooltipProviderContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ 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__ */ jsxRuntimeExports.jsx(
+    TooltipProvider$1,
+    {
+      "data-slot": "tooltip-provider",
+      delay,
+      ...props
+    }
+  );
+}
+function Tooltip({ ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(TooltipRoot, { "data-slot": "tooltip", ...props });
+}
+function TooltipTrigger2({ ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(TooltipTrigger$1, { "data-slot": "tooltip-trigger", ...props });
+}
+function TooltipContent({
+  className,
+  side = "top",
+  sideOffset = 4,
+  align = "center",
+  alignOffset = 0,
+  children,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(TooltipPortal, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+    TooltipPositioner,
+    {
+      align,
+      alignOffset,
+      side,
+      sideOffset,
+      className: "isolate z-50",
+      children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        TooltipPopup,
+        {
+          "data-slot": "tooltip-content",
+          className: 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__ */ 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" })
+          ]
+        }
+      )
+    }
+  ) });
+}
+export {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider2 as TooltipProvider,
+  TooltipTrigger2 as TooltipTrigger
+};
+//# sourceMappingURL=index.mjs.map