@servicetitan/anvil2 1.44.1 → 1.45.0

package/dist/Tooltip-BI3Xs75X.js

@@ -0,0 +1,730 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useContext, createContext, forwardRef, useId, useRef, useLayoutEffect, useState, useEffect, useMemo, cloneElement, isValidElement, Fragment, useCallback } from 'react';
+import { c as cx } from './index-tZvMCc77.js';
+import { T as ThemeProviderContext } from './ThemeProviderContext-l52GohYT.js';
+import { D as DialogContext, a as DrawerContext, G as useDelayGroup, y as FloatingPortal, H as FloatingArrow, s as supportsPopover, I as useDelayGroupContext, f as useFloating, o as offset, g as flip, h as shift, J as arrow$1, A as autoUpdate, l as limitShift, j as useHover, k as safePolygon, K as useFocus, p as useDismiss, n as useRole, v as useInteractions, B as computePosition, C as safeShowPopover, E as safeHidePopover } from './DrawerContext-DboTgTmo.js';
+import { P as PortalProviderContext } from './PortalProvider-9lXkQ0xY.js';
+import { T as ThemeProvider } from './ThemeProvider-Be3Pvtpz.js';
+import { u as useMergeRefs } from './useMergeRefs-Bde85AWI.js';
+import { g as getKeyboardFocusableElements } from './getKeyboardFocusableElements-QqcABz0D.js';
+import { u as useTooltipLegacyGroup } from './AnvilProvider-C_qRQnE6.js';
+import { c as childrenToString } from './childrenToString-Bz9MqbHb.js';
+import { useTrackingId } from './useTrackingId.js';
+
+import './Tooltip.css';const TooltipLegacyContext = createContext(null);
+const useTooltipLegacyContext = () => {
+  const context = useContext(TooltipLegacyContext);
+  if (context == null) {
+    throw new Error(
+      "TooltipLegacy components must be wrapped in <TooltipLegacy />"
+    );
+  }
+  return context;
+};
+
+const styles$1 = {
+	"content-legacy": "_content-legacy_3w3om_3",
+	"arrow-legacy": "_arrow-legacy_3w3om_29",
+	"trigger-legacy": "_trigger-legacy_3w3om_32"
+};
+
+const TooltipLegacyContent = forwardRef(function TooltipLegacyContent2({ style, className, ...props }, propRef) {
+  const {
+    context: floatingContext,
+    theme,
+    mode,
+    root,
+    ...context
+  } = useTooltipLegacyContext();
+  const { root: portalRoot } = useContext(PortalProviderContext);
+  const dialogContext = useContext(DialogContext);
+  const drawerContext = useContext(DrawerContext);
+  const id = useId();
+  useDelayGroup(floatingContext, { id });
+  const ref = useMergeRefs([context.refs.setFloating, propRef]);
+  if (!floatingContext.open) return null;
+  const contentCx = cx(styles$1["content-legacy"], className);
+  return /* @__PURE__ */ jsx(
+    FloatingPortal,
+    {
+      root: root ?? dialogContext?.ref?.current ?? drawerContext?.ref?.current ?? portalRoot ?? context.refs.reference,
+      children: /* @__PURE__ */ jsx(ThemeProvider, { theme, mode, children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          ref,
+          className: contentCx,
+          "data-anv": "tooltip-content",
+          style: {
+            ...context.floatingStyles,
+            ...style
+          },
+          onBlur: () => context.setOpen(false),
+          ...context.getFloatingProps(props),
+          children: [
+            /* @__PURE__ */ jsx(
+              FloatingArrow,
+              {
+                ref: context.arrowRef,
+                context: floatingContext,
+                className: styles$1["arrow-legacy"]
+              }
+            ),
+            props.children
+          ]
+        }
+      ) })
+    }
+  );
+});
+
+const TooltipContext = createContext(null);
+
+function useTooltipContext() {
+  const context = useContext(TooltipContext);
+  const invokerRef = useRef(null);
+  const popoverRef = useRef(null);
+  const arrowRef = useRef(null);
+  useLayoutEffect(() => {
+    if (!invokerRef.current) return;
+    context?.setInvoker?.(invokerRef.current);
+    if (!context?.openState) return;
+    context.openTooltip();
+  }, [context, invokerRef]);
+  useLayoutEffect(() => {
+    if (!popoverRef.current) return;
+    context?.setTooltip?.(popoverRef.current);
+    context?.setRootNode?.(popoverRef.current.getRootNode());
+    if (!arrowRef.current) return;
+    context?.setArrowElement?.(arrowRef.current);
+  }, [context, popoverRef]);
+  const onMouseEnterHandler = () => {
+    if (context?.controlled) return;
+    context?.openTooltip();
+  };
+  const onMouseLeaveHandler = () => {
+    if (context?.controlled) return;
+    context?.closeTooltip();
+  };
+  const onFocusHandler = () => {
+    if (context?.controlled) return;
+    context?.openTooltip();
+  };
+  const onBlurHandler = () => {
+    if (context?.controlled) return;
+    context?.closeTooltip();
+  };
+  const onKeyDownHandler = (e) => {
+    if (!context?.openState) return;
+    if (e.code === "Escape" && !context.controlled) {
+      context?.closeTooltip();
+      return;
+    }
+  };
+  if (!context || !invokerRef || !popoverRef) return;
+  return {
+    invoker: {
+      ref: invokerRef,
+      element: context.invoker,
+      onMouseEnter: onMouseEnterHandler,
+      onMouseLeave: onMouseLeaveHandler,
+      onKeyDown: onKeyDownHandler,
+      onFocus: onFocusHandler,
+      onBlur: onBlurHandler,
+      "aria-haspopup": true,
+      "aria-details": context.tooltipId,
+      "data-state": context.openState ? "open" : "closed",
+      "aria-describedby": context.tooltipId
+    },
+    tooltip: {
+      ref: popoverRef,
+      element: context.popover,
+      id: context.tooltipId,
+      setId: context.setTooltipId,
+      show: context.openTooltip,
+      close: context.closeTooltip,
+      style: context.tooltipStyle,
+      arrowRef,
+      key: context.resetKey
+    },
+    setOpen: context.setOpenState,
+    open: context.openState,
+    controlled: context.controlled,
+    placement: context.placement,
+    disableFlipFallback: context.disableFlipFallback
+  };
+}
+
+const content = "_content_1tuax_2";
+const scroller = "_scroller_1tuax_29";
+const arrow = "_arrow_1tuax_32";
+const trigger = "_trigger_1tuax_39";
+const styles = {
+	content: content,
+	scroller: scroller,
+	arrow: arrow,
+	trigger: trigger
+};
+
+const TooltipContentElement = forwardRef(
+  function TooltipContent2(props, ref) {
+    const {
+      children,
+      className,
+      style,
+      onMouseEnter,
+      onMouseLeave,
+      onKeyDown,
+      onFocus,
+      onBlur,
+      id,
+      ...rest
+    } = props;
+    const context = useTooltipContext();
+    const { mode: currentMode } = useContext(ThemeProviderContext);
+    const tooltipClassNames = cx(className, styles["content"]);
+    const childrenRef = useRef(null);
+    const focusItems = useRef();
+    const combinedStyles = {
+      ...style,
+      ...context?.tooltip.style
+    };
+    const tooltipMode = currentMode === "dark" ? "light" : "dark";
+    useLayoutEffect(() => {
+      if (!childrenRef.current) return;
+      const focusElements = getKeyboardFocusableElements(childrenRef.current);
+      focusItems.current = focusElements;
+    }, [childrenRef, children, context?.open]);
+    useLayoutEffect(() => {
+      if (id) {
+        context?.tooltip.setId(id);
+      }
+    }, [id, context?.tooltip.setId, context?.tooltip]);
+    const onMouseEnterHandler = (e) => {
+      onMouseEnter?.(e);
+      if (context?.controlled) return;
+      context?.tooltip.show();
+    };
+    const onMouseLeaveHandler = (e) => {
+      onMouseLeave?.(e);
+      if (context?.controlled) return;
+      context?.tooltip.close();
+    };
+    const onFocusHandler = (e) => {
+      onFocus?.(e);
+      if (context?.controlled) return;
+      context?.tooltip.show();
+    };
+    const onBlurHandler = (e) => {
+      onBlur?.(e);
+      if (context?.controlled) return;
+      context?.tooltip.close();
+    };
+    const onKeyDownHandler = (e) => {
+      onKeyDown?.(e);
+      if (!context?.open) return;
+      if (e.code === "Escape") {
+        context?.tooltip.close();
+      }
+    };
+    const hasSimpleContent = typeof children === "string";
+    const role = hasSimpleContent ? "tooltip" : "region";
+    const tooltipWrapperRef = useMergeRefs([context?.tooltip.ref, ref]);
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        popover: context?.controlled ? "manual" : "auto",
+        "data-anv": "tooltip-content",
+        className: tooltipClassNames,
+        ref: tooltipWrapperRef,
+        style: combinedStyles,
+        onMouseEnter: onMouseEnterHandler,
+        onMouseLeave: onMouseLeaveHandler,
+        onBlur: onBlurHandler,
+        onFocus: onFocusHandler,
+        role,
+        id: context?.tooltip.id,
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: styles.scroller,
+              role: "presentation",
+              tabIndex: -1,
+              ref: childrenRef,
+              onKeyDown: onKeyDownHandler,
+              children: hasSimpleContent ? children : /* @__PURE__ */ jsx(ThemeProvider, { mode: tooltipMode, "data-anv": "tooltip-content-theme", children })
+            },
+            context?.tooltip.key
+          ),
+          /* @__PURE__ */ jsx("span", { className: styles["arrow"], ref: context?.tooltip.arrowRef, children: /* @__PURE__ */ jsxs("svg", { "aria-hidden": "true", width: "14", height: "14", viewBox: "0 0 14 14", children: [
+            /* @__PURE__ */ jsx("path", { stroke: "none", d: "M0,0 H14 L7,7 Q7,7 7,7 Z" }),
+            /* @__PURE__ */ jsx("clipPath", { id: ":r9:", children: /* @__PURE__ */ jsx("rect", { x: "0", y: "0", width: "14", height: "14" }) })
+          ] }) })
+        ]
+      }
+    );
+  }
+);
+const TooltipContent = forwardRef(
+  function TooltipContent3(props, ref) {
+    if (!supportsPopover())
+      return /* @__PURE__ */ jsx(TooltipLegacyContent, { ...props, ref });
+    return /* @__PURE__ */ jsx(TooltipContentElement, { ...props, ref });
+  }
+);
+
+function useTooltipLegacy({
+  defaultOpen = false,
+  offset: offsetProp = 5,
+  open: controlledOpen,
+  placement = "top",
+  fallbackPlacements,
+  disableFlip,
+  disableShift,
+  root
+} = {}) {
+  const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen);
+  const open = controlledOpen ?? uncontrolledOpen;
+  const setOpen = setUncontrolledOpen;
+  const { disableDelayGroup } = useTooltipLegacyGroup();
+  useEffect(() => {
+    if (!defaultOpen && !controlledOpen) {
+      disableDelayGroup(true);
+    }
+    disableDelayGroup(false);
+  }, [defaultOpen, controlledOpen, disableDelayGroup]);
+  const arrowRef = useRef(null);
+  const { delay } = useDelayGroupContext();
+  const data = useFloating({
+    placement,
+    open,
+    onOpenChange: setOpen,
+    whileElementsMounted: autoUpdate,
+    middleware: [
+      offset(offsetProp),
+      flip({
+        crossAxis: !disableFlip ? placement.includes("-") : false,
+        mainAxis: !disableFlip,
+        fallbackAxisSideDirection: "start",
+        fallbackPlacements,
+        padding: 5
+      }),
+      shift({
+        padding: 5,
+        mainAxis: !disableShift,
+        crossAxis: false,
+        limiter: limitShift({
+          mainAxis: !disableShift
+        })
+      }),
+      arrow$1({ element: arrowRef, padding: 5 })
+    ]
+  });
+  const context = data.context;
+  const hover = useHover(context, {
+    move: false,
+    handleClose: safePolygon(),
+    delay
+  });
+  const focus = useFocus(context, {});
+  const dismiss = useDismiss(context);
+  const role = useRole(context, { role: "tooltip" });
+  const interactions = useInteractions([hover, focus, dismiss, role]);
+  return useMemo(
+    () => ({
+      open,
+      setOpen,
+      arrowRef,
+      root,
+      ...interactions,
+      ...data
+    }),
+    [open, setOpen, interactions, data, root]
+  );
+}
+
+const TooltipLegacyTrigger = forwardRef(function TooltipLegacyTrigger2({ children, className, ...props }, propRef) {
+  const context = useTooltipLegacyContext();
+  const ref = useMergeRefs([context.refs.setReference, propRef]);
+  const { "aria-describedby": ariaDescribedBy, ...restOfContextProps } = context.getReferenceProps(props);
+  const child = cloneElement(children, {
+    ref,
+    "aria-describedby": ariaDescribedBy
+  });
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      ref,
+      className: cx([styles$1["trigger-legacy"]], className),
+      "data-anv": "tooltip-trigger",
+      "data-state": context.open ? "open" : "closed",
+      ...restOfContextProps,
+      children: child
+    }
+  );
+});
+
+function TooltipLegacyElement({
+  children,
+  ...options
+}) {
+  const tooltip = useTooltipLegacy(options);
+  const { theme, mode } = useContext(ThemeProviderContext);
+  const value = useMemo(
+    () => ({ ...tooltip, theme, mode }),
+    [mode, theme, tooltip]
+  );
+  return /* @__PURE__ */ jsx(TooltipLegacyContext.Provider, { value, children });
+}
+const TooltipLegacy = Object.assign(TooltipLegacyElement, {
+  Trigger: TooltipLegacyTrigger,
+  Content: TooltipLegacyContent
+});
+
+const INTERACTIVE_ELEMENTS = ["button", "a", "input", "textarea", "select"];
+function isNonInteractiveElement(element) {
+  if (!isValidElement(element)) return false;
+  const type = element.type;
+  return typeof type === "string" && !INTERACTIVE_ELEMENTS.includes(type);
+}
+
+const TooltipTriggerElement = forwardRef(
+  function TooltipTrigger2(props, propRef) {
+    const { children, className, onKeyDown, onFocus, onBlur, ...rest } = props;
+    const context = useTooltipContext();
+    const childCanAcceptRef = useMemo(
+      () => isValidElement(children) && children.type !== Fragment && typeof children.type !== "function",
+      [children]
+    );
+    const refs = useMergeRefs([
+      children?.ref,
+      context?.invoker.ref
+    ]);
+    const childProps = useMemo(() => {
+      const baseProps = {
+        ref: refs,
+        "aria-haspopup": context?.invoker["aria-haspopup"],
+        "aria-details": context?.invoker["aria-details"],
+        "data-state": context?.invoker["data-state"],
+        "aria-describedby": context?.invoker["aria-describedby"]
+      };
+      if (isNonInteractiveElement(children)) {
+        if (!("tabIndex" in (children.props || {}))) {
+          baseProps.tabIndex = 0;
+        }
+        if (!("role" in (children.props || {}))) {
+          baseProps.role = "button";
+        }
+      }
+      return baseProps;
+    }, [context?.invoker, refs, children]);
+    const child = childCanAcceptRef ? cloneElement(children, childProps) : /* @__PURE__ */ jsx("span", { ...childProps, children });
+    const onKeyDownHandler = (e) => {
+      onKeyDown?.(e);
+      context?.invoker.onKeyDown(e);
+    };
+    const onFocusHandler = (e) => {
+      onFocus?.(e);
+      context?.invoker.onFocus();
+    };
+    const onBlurHandler = (e) => {
+      onBlur?.(e);
+      context?.invoker.onBlur();
+    };
+    useLayoutEffect(() => {
+      const onMouseEnterHandler = () => {
+        context?.invoker.onMouseEnter();
+      };
+      const onMouseLeaveHandler = () => {
+        context?.invoker.onMouseLeave();
+      };
+      context?.invoker.ref.current?.addEventListener(
+        "mouseleave",
+        onMouseLeaveHandler
+      );
+      context?.invoker.ref.current?.addEventListener(
+        "mouseenter",
+        onMouseEnterHandler
+      );
+      return () => {
+        context?.invoker.ref.current?.removeEventListener(
+          "mouseleave",
+          onMouseLeaveHandler
+        );
+        context?.invoker.ref.current?.removeEventListener(
+          "mouseenter",
+          onMouseEnterHandler
+        );
+      };
+    }, [context?.invoker]);
+    const data = {
+      children: childrenToString(props.children)
+    };
+    const trackingId = useTrackingId({
+      name: "TooltipTrigger",
+      data,
+      hasOverride: !!props["data-tracking-id"]
+    });
+    if (!supportsPopover()) return /* @__PURE__ */ jsx(TooltipLegacyTrigger, { ...props });
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: cx([styles["trigger"]], className),
+        "data-anv": "tooltip-trigger",
+        "data-tracking-id": trackingId,
+        ref: propRef,
+        onKeyDown: onKeyDownHandler,
+        onFocus: onFocusHandler,
+        onBlur: onBlurHandler,
+        role: "presentation",
+        ...rest,
+        children: child
+      }
+    );
+  }
+);
+const TooltipTrigger = forwardRef(
+  function TooltipTrigger3(props, propRef) {
+    if (!supportsPopover())
+      return /* @__PURE__ */ jsx(TooltipLegacyTrigger, { ...props, ref: propRef });
+    return /* @__PURE__ */ jsx(TooltipTriggerElement, { ...props, ref: propRef });
+  }
+);
+
+const TooltipElement = (props) => {
+  const {
+    children,
+    delay = 100,
+    placement = "top",
+    open,
+    defaultOpen = false,
+    disableShift,
+    disableFlip,
+    disableFlipFallback,
+    id,
+    offset: offsetProp = 5,
+    fallbackPlacements
+  } = props;
+  const uid = useId();
+  const [invoker, setInvoker] = useState(void 0);
+  const [tooltip, setTooltip] = useState(void 0);
+  const [rootNode, setRootNode] = useState();
+  const [arrowElement, setArrowElement] = useState(void 0);
+  const [openState, setOpenState] = useState(
+    open ?? defaultOpen
+  );
+  const arrowRef = useRef(null);
+  const [tooltipId, setTooltipId] = useState(
+    id ?? `tooltip-${uid.replace(/:/g, "")}`
+  );
+  const updatePosition = useCallback(() => {
+    if (!invoker || !tooltip) return;
+    if (!openState) return;
+    computePosition(invoker, tooltip, {
+      placement,
+      middleware: [
+        offset(offsetProp),
+        flip({
+          mainAxis: !disableFlip,
+          crossAxis: false,
+          fallbackAxisSideDirection: disableFlipFallback ? "none" : "end",
+          fallbackPlacements,
+          padding: 5
+        }),
+        shift({
+          padding: 5,
+          mainAxis: !disableShift,
+          crossAxis: false,
+          limiter: limitShift({
+            mainAxis: !disableShift
+          })
+        }),
+        arrow$1({
+          element: arrowElement ? arrowElement : null,
+          padding: 5
+        })
+      ]
+    }).then(({ x, y, placement: placement2, middlewareData }) => {
+      const side = placement2.split("-")[0];
+      const staticSide = {
+        top: "bottom",
+        right: "left",
+        bottom: "top",
+        left: "right"
+      }[side];
+      const arrowDeg = () => {
+        if (staticSide === "top") return 180;
+        if (staticSide === "bottom") return 0;
+        if (staticSide === "left") return 90;
+        return 270;
+      };
+      Object.assign(tooltip.style, {
+        left: `${x}px`,
+        top: `${y}px`
+      });
+      if (middlewareData.arrow && arrowElement) {
+        const { x: x2, y: y2 } = middlewareData.arrow;
+        Object.assign(arrowElement.style, {
+          left: x2 != null ? `${x2}px` : "",
+          top: y2 != null ? `${y2}px` : "",
+          right: "",
+          bottom: "",
+          [staticSide]: `${-arrowElement.offsetWidth + 2}px`,
+          transform: `rotate(${arrowDeg()}deg)`
+        });
+      }
+    });
+  }, [
+    invoker,
+    tooltip,
+    openState,
+    placement,
+    offsetProp,
+    disableFlip,
+    disableFlipFallback,
+    fallbackPlacements,
+    disableShift,
+    arrowElement
+  ]);
+  const resetKey = useRef(0);
+  useLayoutEffect(() => {
+    if (!tooltip || !invoker) return;
+    if (!openState) {
+      resetKey.current += 1;
+      return;
+    }
+    let requestID = null;
+    const cleanup = autoUpdate(invoker, tooltip, () => {
+      requestID = requestAnimationFrame(updatePosition);
+    });
+    return () => {
+      if (requestID) cancelAnimationFrame(requestID);
+      cleanup();
+    };
+  }, [invoker, tooltip, updatePosition, openState]);
+  const isControlled = typeof open !== "undefined";
+  const openTimeoutRef = useRef(null);
+  const closeTimeoutRef = useRef(null);
+  const openTooltip = useCallback(() => {
+    clearTimeout(closeTimeoutRef.current);
+    clearTimeout(openTimeoutRef.current);
+    if (!tooltip || !rootNode?.querySelector(`#${tooltipId}`)) return;
+    openTimeoutRef.current = setTimeout(() => {
+      safeShowPopover(tooltip);
+      setOpenState(true);
+    }, delay);
+  }, [tooltip, rootNode, tooltipId, delay]);
+  const closeTooltip = useCallback(
+    (fn) => {
+      clearTimeout(openTimeoutRef.current);
+      clearTimeout(closeTimeoutRef.current);
+      if (!tooltip || !openState) return;
+      closeTimeoutRef.current = setTimeout(() => {
+        fn?.();
+        setOpenState(false);
+        safeHidePopover(tooltip);
+      }, 100);
+    },
+    [openState, tooltip]
+  );
+  const initialRender = useRef(true);
+  useEffect(() => {
+    if (initialRender.current === true) {
+      if (openState) openTooltip();
+      initialRender.current = false;
+      return;
+    }
+  }, [openTooltip, openState, isControlled]);
+  useEffect(() => {
+    if (!isControlled) return;
+    if (open) {
+      openTooltip();
+    } else {
+      closeTooltip();
+    }
+  }, [closeTooltip, isControlled, open, openTooltip]);
+  const value = useMemo(() => {
+    updatePosition();
+    return {
+      tooltipId,
+      setTooltipId,
+      invoker,
+      setInvoker,
+      tooltip,
+      setTooltip,
+      arrowElement,
+      setArrowElement,
+      openTooltip,
+      closeTooltip,
+      placement,
+      openState,
+      setOpenState,
+      disableFlipFallback,
+      controlled: isControlled,
+      arrowRef,
+      resetKey: resetKey.current,
+      rootNode,
+      setRootNode
+    };
+  }, [
+    updatePosition,
+    tooltipId,
+    setTooltipId,
+    invoker,
+    tooltip,
+    arrowElement,
+    openTooltip,
+    closeTooltip,
+    placement,
+    openState,
+    disableFlipFallback,
+    isControlled,
+    rootNode
+  ]);
+  if (!supportsPopover()) return /* @__PURE__ */ jsx(TooltipLegacy, { ...props });
+  return /* @__PURE__ */ jsx(TooltipContext.Provider, { value, children });
+};
+const Tooltip = Object.assign(TooltipElement, {
+  /**
+   * TooltipTrigger component that wraps the element that triggers the tooltip.
+   *
+   * Features:
+   * - Wraps any React element to make it a tooltip trigger
+   * - Handles mouse and keyboard interactions
+   * - Provides proper ARIA attributes for accessibility
+   * - Supports all standard HTML element props
+   * - Automatically clones child elements with proper refs
+   * - Handles both focusable and non-focusable children
+   * - Manages mouse enter/leave events for hover behavior
+   *
+   * @example
+   * <Tooltip.Trigger>
+   *   <Button>Click me</Button>
+   * </Tooltip.Trigger>
+   */
+  Trigger: TooltipTrigger,
+  /**
+   * TooltipContent component that displays the tooltip content.
+   *
+   * Features:
+   * - Displays the tooltip content with proper positioning
+   * - Includes an arrow pointing to the trigger element
+   * - Supports keyboard navigation and escape key to close
+   * - Handles mouse interactions for hover behavior
+   * - Accessible with proper ARIA roles
+   * - Supports all standard div element props
+   * - Automatic focus management for keyboard navigation
+   * - Real-time position updates
+   * - Handles both string and complex content
+   *
+   * @example
+   * <Tooltip.Content>
+   *   This tooltip provides helpful context
+   * </Tooltip.Content>
+   */
+  Content: TooltipContent
+});
+
+export { Tooltip as T, TooltipContent as a, TooltipTrigger as b };
+//# sourceMappingURL=Tooltip-BI3Xs75X.js.map