@servicetitan/anvil2 1.29.0 → 1.31.0

package/dist/Tooltip-C8sCGmKM-CLrDofvy.js

@@ -1,631 +0,0 @@
-import { jsx, jsxs } from 'react/jsx-runtime';
-import { createContext, forwardRef, useContext, useId, cloneElement, useMemo, useState, useEffect, useRef, useLayoutEffect, useCallback } from 'react';
-import { c as cx } from './index-tZvMCc77.js';
-import { s as supportsPopover } from './supportsPopover-8aJR37cf-8aJR37cf.js';
-import { a as useDelayGroup, F as FloatingPortal, b as FloatingArrow, c as useDelayGroupContext, d as useFloating, e as autoUpdate, o as offset, f as flip, s as shift, l as limitShift, g as arrow$1, h as useHover, i as safePolygon, j as useFocus, k as useDismiss, m as useRole, n as useInteractions, p as computePosition } from './floating-ui.react-4AwURJA3.js';
-import { u as useTooltipLegacyGroup } from './HammerProvider-DuxhW0gv-C2voN5ro.js';
-import { u as useMergeRefs } from './useMergeRefs-Bde85AWI-Bde85AWI.js';
-import { a as PortalProviderContext } from './PortalProvider-9lXkQ0xY-BKoGegS1.js';
-import { e as DialogContext } from './Dialog-CYBt_JdP-CmF0MUHL.js';
-import { e as DrawerContext } from './Drawer-UQlX-LQG-BSCnMRad.js';
-import { T as ThemeProvider, a as ThemeProviderContext } from './ThemeProvider-CioBp3gk-B6HyDICa.js';
-import { g as getKeyboardFocusableElements } from './getKeyboardFocusableElements-QqcABz0D.js';
-
-import './Tooltip-C8sCGmKM.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_19gkz_4",
-	"arrow-legacy": "_arrow-legacy_19gkz_30",
-	"trigger-legacy": "_trigger-legacy_19gkz_33"
-};
-
-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 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 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]
-  );
-}
-
-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 content = "_content_tjoaw_3";
-const scroller = "_scroller_tjoaw_30";
-const arrow = "_arrow_tjoaw_33";
-const trigger = "_trigger_tjoaw_39";
-const styles = {
-	content: content,
-	scroller: scroller,
-	arrow: arrow,
-	trigger: trigger
-};
-
-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 = () => {
-    context?.openTooltip();
-  };
-  const onMouseLeaveHandler = () => {
-    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-expanded": context.openState,
-      "aria-details": context.tooltipId,
-      "data-state": context.openState ? "open" : "closed",
-      "aria-describedby": context.tooltipId
-    },
-    tooltip: {
-      ref: popoverRef,
-      element: context.popover,
-      id: context.tooltipId,
-      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 TooltipContentElement = forwardRef(
-  function TooltipContent2(props, ref) {
-    const {
-      children,
-      className,
-      style,
-      onMouseEnter,
-      onMouseLeave,
-      onKeyDown,
-      onFocus,
-      onBlur,
-      ...rest
-    } = props;
-    const context = useTooltipContext();
-    const tooltipClassNames = cx(className, styles["content"]);
-    const childrenRef = useRef(null);
-    const focusItems = useRef();
-    const combinedStyles = {
-      ...style,
-      ...context?.tooltip.style
-    };
-    useLayoutEffect(() => {
-      if (!childrenRef.current) return;
-      const focusElements = getKeyboardFocusableElements(childrenRef.current);
-      focusItems.current = focusElements;
-    }, [childrenRef, children, context?.open]);
-    const onMouseEnterHandler = (e) => {
-      onMouseEnter?.(e);
-      context?.tooltip.show();
-    };
-    const onMouseLeaveHandler = (e) => {
-      onMouseLeave?.(e);
-      context?.tooltip.close();
-    };
-    const onFocusHandler = (e) => {
-      onFocus?.(e);
-      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 tooltipWrapperRef = useMergeRefs([context?.tooltip.ref, ref]);
-    return /* @__PURE__ */ jsxs(
-      "div",
-      {
-        popover: "manual",
-        id: context?.tooltip.id,
-        "data-anv": "tooltip-content",
-        className: tooltipClassNames,
-        ref: tooltipWrapperRef,
-        style: combinedStyles,
-        onMouseEnter: onMouseEnterHandler,
-        onMouseLeave: onMouseLeaveHandler,
-        onBlur: onBlurHandler,
-        onFocus: onFocusHandler,
-        role: "tooltip",
-        ...rest,
-        children: [
-          /* @__PURE__ */ jsx(
-            "div",
-            {
-              className: styles.scroller,
-              role: "presentation",
-              tabIndex: -1,
-              ref: childrenRef,
-              onKeyDown: onKeyDownHandler,
-              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 });
-  }
-);
-
-const TooltipTriggerElement = forwardRef(
-  function TooltipTrigger2(props, propRef) {
-    const {
-      children,
-      className,
-      onMouseEnter,
-      onMouseLeave,
-      onKeyDown,
-      onFocus,
-      onBlur,
-      ...rest
-    } = props;
-    const context = useTooltipContext();
-    const child = cloneElement(children, {
-      ref: context?.invoker.ref,
-      "aria-haspopup": context?.invoker["aria-haspopup"],
-      "aria-expanded": context?.invoker["aria-expanded"],
-      "aria-details": context?.invoker["aria-details"],
-      "data-state": context?.invoker["data-state"],
-      "aria-describedby": context?.invoker["aria-describedby"]
-    });
-    const onMouseEnterHandler = (e) => {
-      onMouseEnter?.(e);
-      context?.invoker.onMouseEnter();
-    };
-    const onMouseLeaveHandler = (e) => {
-      onMouseLeave?.(e);
-      context?.invoker.onMouseLeave();
-    };
-    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();
-    };
-    if (!supportsPopover()) return /* @__PURE__ */ jsx(TooltipLegacyTrigger, { ...props });
-    return /* @__PURE__ */ jsx(
-      "span",
-      {
-        className: cx([styles["trigger"]], className),
-        "data-anv": "tooltip-trigger",
-        ref: propRef,
-        onMouseEnter: onMouseEnterHandler,
-        onMouseLeave: onMouseLeaveHandler,
-        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 TooltipContext = createContext(null);
-const TooltipElement = (props) => {
-  const {
-    children,
-    delay = 100,
-    placement = "top",
-    open,
-    defaultOpen = false,
-    disableShift,
-    disableFlip,
-    disableFlipFallback,
-    id,
-    offset: offsetProp = 5,
-    fallbackPlacements,
-    root
-  } = props;
-  const uid = useId();
-  const [invoker, setInvoker] = useState(undefined);
-  const [tooltip, setTooltip] = useState(undefined);
-  const [rootNode, setRootNode] = useState();
-  const [arrowElement, setArrowElement] = useState(undefined);
-  const [openState, setOpenState] = useState(
-    open ?? defaultOpen
-  );
-  const arrowRef = useRef(null);
-  const dialogContext = useContext(DialogContext);
-  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 () => {
-      requestID && cancelAnimationFrame(requestID);
-      cleanup();
-    };
-  }, [invoker, tooltip, updatePosition, openState]);
-  const popoverHoverTriggered = useRef();
-  const openTooltip = useCallback(async () => {
-    popoverHoverTriggered.current = true;
-    await new Promise((resolve) => setTimeout(resolve, delay));
-    if (!popoverHoverTriggered.current || !tooltip || !rootNode?.querySelector(`#${id ?? `tooltip-${uid.replace(/:/g, "")}`}`))
-      return;
-    tooltip.showPopover();
-    setOpenState(true);
-    dialogContext?.setHasOpenPopover?.(true);
-  }, [tooltip, rootNode, id, uid, dialogContext, delay]);
-  const closeTooltip = useCallback(
-    async (fn) => {
-      popoverHoverTriggered.current = false;
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      if (popoverHoverTriggered.current || !tooltip || !openState) return;
-      fn?.();
-      setOpenState(false);
-      tooltip?.hidePopover();
-      dialogContext?.setHasOpenPopover?.(false);
-    },
-    [tooltip, openState, dialogContext]
-  );
-  const isControlled = typeof open !== "undefined";
-  const initialRender = useRef(true);
-  useEffect(() => {
-    if (!isControlled) return;
-    if (initialRender.current === true) {
-      open && tooltip && openTooltip();
-      initialRender.current = false;
-      return;
-    }
-    setOpenState(open);
-    open ? openTooltip() : closeTooltip();
-  }, [closeTooltip, isControlled, open, openTooltip, tooltip]);
-  const value = useMemo(() => {
-    updatePosition();
-    return {
-      tooltipId: id ?? `tooltip-${uid.replace(/:/g, "")}`,
-      invoker,
-      setInvoker,
-      tooltip,
-      setTooltip,
-      arrowElement,
-      setArrowElement,
-      openTooltip,
-      closeTooltip,
-      placement,
-      openState,
-      setOpenState,
-      disableFlipFallback,
-      controlled: isControlled,
-      arrowRef,
-      resetKey: resetKey.current,
-      rootNode,
-      setRootNode
-    };
-  }, [
-    updatePosition,
-    id,
-    uid,
-    invoker,
-    tooltip,
-    arrowElement,
-    openTooltip,
-    closeTooltip,
-    placement,
-    openState,
-    disableFlipFallback,
-    isControlled,
-    arrowRef,
-    resetKey,
-    rootNode,
-    setRootNode
-  ]);
-  if (!supportsPopover()) return /* @__PURE__ */ jsx(TooltipLegacy, { ...props });
-  return /* @__PURE__ */ jsx(TooltipContext.Provider, { value, children });
-};
-const Tooltip = Object.assign(TooltipElement, {
-  Trigger: TooltipTrigger,
-  Content: TooltipContent,
-  Context: TooltipContext
-});
-
-export { TooltipTrigger as T, TooltipContent as a, Tooltip as b };
-//# sourceMappingURL=Tooltip-C8sCGmKM-CLrDofvy.js.map