https://lcca-driven.replit.app/@fs/home/runner/workspace/node_modu…/deps/@radix-ui_react-tooltip.js?v=ca3f123c

1"use client";
2import {
3  Anchor,
4  Arrow,
5  Content,
6  Root2,
7  createPopperScope
8} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-KJJK7F56.js?v=ca3f123c";
9import {
10  DismissableLayer,
11  Portal,
12  Root2 as Root
13} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-TO6V3G2O.js?v=ca3f123c";
14import {
15  Presence
16} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-OWY5JNM4.js?v=ca3f123c";
17import {
18  useId
19} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-BX2JTGRN.js?v=ca3f123c";
20import {
21  composeEventHandlers,
22  createContextScope,
23  useControllableState
24} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-T7LAPN5H.js?v=ca3f123c";
25import {
26  Primitive
27} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-VK2OJPQA.js?v=ca3f123c";
28import {
29  createSlottable,
30  useComposedRefs
31} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-6LRRM7M2.js?v=ca3f123c";
32import "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-WERSD76P.js?v=ca3f123c";
33import {
34  require_jsx_runtime
35} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-S77I6LSE.js?v=ca3f123c";
36import {
37  require_react
38} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-3TFVT2CW.js?v=ca3f123c";
39import {
40  __toESM
41} from "/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-4MBMRILA.js?v=ca3f123c";
42
43// node_modules/@radix-ui/react-tooltip/dist/index.mjs
44var React = __toESM(require_react(), 1);
45var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
46var [createTooltipContext, createTooltipScope] = createContextScope("Tooltip", [
47  createPopperScope
48]);
49var usePopperScope = createPopperScope();
50var PROVIDER_NAME = "TooltipProvider";
51var DEFAULT_DELAY_DURATION = 700;
52var TOOLTIP_OPEN = "tooltip.open";
53var [TooltipProviderContextProvider, useTooltipProviderContext] = createTooltipContext(PROVIDER_NAME);
54var TooltipProvider = (props) => {
55  const {
56    __scopeTooltip,
57    delayDuration = DEFAULT_DELAY_DURATION,
58    skipDelayDuration = 300,
59    disableHoverableContent = false,
60    children
61  } = props;
62  const isOpenDelayedRef = React.useRef(true);
63  const isPointerInTransitRef = React.useRef(false);
64  const skipDelayTimerRef = React.useRef(0);
65  React.useEffect(() => {
66    const skipDelayTimer = skipDelayTimerRef.current;
67    return () => window.clearTimeout(skipDelayTimer);
68  }, []);
69  return (0, import_jsx_runtime.jsx)(
70    TooltipProviderContextProvider,
71    {
72      scope: __scopeTooltip,
73      isOpenDelayedRef,
74      delayDuration,
75      onOpen: React.useCallback(() => {
76        window.clearTimeout(skipDelayTimerRef.current);
77        isOpenDelayedRef.current = false;
78      }, []),
79      onClose: React.useCallback(() => {
80        window.clearTimeout(skipDelayTimerRef.current);
81        skipDelayTimerRef.current = window.setTimeout(
82          () => isOpenDelayedRef.current = true,
83          skipDelayDuration
84        );
85      }, [skipDelayDuration]),
86      isPointerInTransitRef,
87      onPointerInTransitChange: React.useCallback((inTransit) => {
88        isPointerInTransitRef.current = inTransit;
89      }, []),
90      disableHoverableContent,
91      children
92    }
93  );
94};
95TooltipProvider.displayName = PROVIDER_NAME;
96var TOOLTIP_NAME = "Tooltip";
97var [TooltipContextProvider, useTooltipContext] = createTooltipContext(TOOLTIP_NAME);
98var Tooltip = (props) => {
99  const {
100    __scopeTooltip,
101    children,
102    open: openProp,
103    defaultOpen,
104    onOpenChange,
105    disableHoverableContent: disableHoverableContentProp,
106    delayDuration: delayDurationProp
107  } = props;
108  const providerContext = useTooltipProviderContext(TOOLTIP_NAME, props.__scopeTooltip);
109  const popperScope = usePopperScope(__scopeTooltip);
110  const [trigger, setTrigger] = React.useState(null);
111  const contentId = useId();
112  const openTimerRef = React.useRef(0);
113  const disableHoverableContent = disableHoverableContentProp ?? providerContext.disableHoverableContent;
114  const delayDuration = delayDurationProp ?? providerContext.delayDuration;
115  const wasOpenDelayedRef = React.useRef(false);
116  const [open, setOpen] = useControllableState({
117    prop: openProp,
118    defaultProp: defaultOpen ?? false,
119    onChange: (open2) => {
120      if (open2) {
121        providerContext.onOpen();
122        document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
123      } else {
124        providerContext.onClose();
125      }
126      onOpenChange == null ? void 0 : onOpenChange(open2);
127    },
128    caller: TOOLTIP_NAME
129  });
130  const stateAttribute = React.useMemo(() => {
131    return open ? wasOpenDelayedRef.current ? "delayed-open" : "instant-open" : "closed";
132  }, [open]);
133  const handleOpen = React.useCallback(() => {
134    window.clearTimeout(openTimerRef.current);
135    openTimerRef.current = 0;
136    wasOpenDelayedRef.current = false;
137    setOpen(true);
138  }, [setOpen]);
139  const handleClose = React.useCallback(() => {
140    window.clearTimeout(openTimerRef.current);
141    openTimerRef.current = 0;
142    setOpen(false);
143  }, [setOpen]);
144  const handleDelayedOpen = React.useCallback(() => {
145    window.clearTimeout(openTimerRef.current);
146    openTimerRef.current = window.setTimeout(() => {
147      wasOpenDelayedRef.current = true;
148      setOpen(true);
149      openTimerRef.current = 0;
150    }, delayDuration);
151  }, [delayDuration, setOpen]);
152  React.useEffect(() => {
153    return () => {
154      if (openTimerRef.current) {
155        window.clearTimeout(openTimerRef.current);
156        openTimerRef.current = 0;
157      }
158    };
159  }, []);
160  return (0, import_jsx_runtime.jsx)(Root2, { ...popperScope, children: (0, import_jsx_runtime.jsx)(
161    TooltipContextProvider,
162    {
163      scope: __scopeTooltip,
164      contentId,
165      open,
166      stateAttribute,
167      trigger,
168      onTriggerChange: setTrigger,
169      onTriggerEnter: React.useCallback(() => {
170        if (providerContext.isOpenDelayedRef.current) handleDelayedOpen();
171        else handleOpen();
172      }, [providerContext.isOpenDelayedRef, handleDelayedOpen, handleOpen]),
173      onTriggerLeave: React.useCallback(() => {
174        if (disableHoverableContent) {
175          handleClose();
176        } else {
177          window.clearTimeout(openTimerRef.current);
178          openTimerRef.current = 0;
179        }
180      }, [handleClose, disableHoverableContent]),
181      onOpen: handleOpen,
182      onClose: handleClose,
183      disableHoverableContent,
184      children
185    }
186  ) });
187};
188Tooltip.displayName = TOOLTIP_NAME;
189var TRIGGER_NAME = "TooltipTrigger";
190var TooltipTrigger = React.forwardRef(
191  (props, forwardedRef) => {
192    const { __scopeTooltip, ...triggerProps } = props;
193    const context = useTooltipContext(TRIGGER_NAME, __scopeTooltip);
194    const providerContext = useTooltipProviderContext(TRIGGER_NAME, __scopeTooltip);
195    const popperScope = usePopperScope(__scopeTooltip);
196    const ref = React.useRef(null);
197    const composedRefs = useComposedRefs(forwardedRef, ref, context.onTriggerChange);
198    const isPointerDownRef = React.useRef(false);
199    const hasPointerMoveOpenedRef = React.useRef(false);
200    const handlePointerUp = React.useCallback(() => isPointerDownRef.current = false, []);
201    React.useEffect(() => {
202      return () => document.removeEventListener("pointerup", handlePointerUp);
203    }, [handlePointerUp]);
204    return (0, import_jsx_runtime.jsx)(Anchor, { asChild: true, ...popperScope, children: (0, import_jsx_runtime.jsx)(
205      Primitive.button,
206      {
207        "aria-describedby": context.open ? context.contentId : void 0,
208        "data-state": context.stateAttribute,
209        ...triggerProps,
210        ref: composedRefs,
211        onPointerMove: composeEventHandlers(props.onPointerMove, (event) => {
212          if (event.pointerType === "touch") return;
213          if (!hasPointerMoveOpenedRef.current && !providerContext.isPointerInTransitRef.current) {
214            context.onTriggerEnter();
215            hasPointerMoveOpenedRef.current = true;
216          }
217        }),
218        onPointerLeave: composeEventHandlers(props.onPointerLeave, () => {
219          context.onTriggerLeave();
220          hasPointerMoveOpenedRef.current = false;
221        }),
222        onPointerDown: composeEventHandlers(props.onPointerDown, () => {
223          if (context.open) {
224            context.onClose();
225          }
226          isPointerDownRef.current = true;
227          document.addEventListener("pointerup", handlePointerUp, { once: true });
228        }),
229        onFocus: composeEventHandlers(props.onFocus, () => {
230          if (!isPointerDownRef.current) context.onOpen();
231        }),
232        onBlur: composeEventHandlers(props.onBlur, context.onClose),
233        onClick: composeEventHandlers(props.onClick, context.onClose)
234      }
235    ) });
236  }
237);
238TooltipTrigger.displayName = TRIGGER_NAME;
239var PORTAL_NAME = "TooltipPortal";
240var [PortalProvider, usePortalContext] = createTooltipContext(PORTAL_NAME, {
241  forceMount: void 0
242});
243var TooltipPortal = (props) => {
244  const { __scopeTooltip, forceMount, children, container } = props;
245  const context = useTooltipContext(PORTAL_NAME, __scopeTooltip);
246  return (0, import_jsx_runtime.jsx)(PortalProvider, { scope: __scopeTooltip, forceMount, children: (0, import_jsx_runtime.jsx)(Presence, { present: forceMount || context.open, children: (0, import_jsx_runtime.jsx)(Portal, { asChild: true, container, children }) }) });
247};
248TooltipPortal.displayName = PORTAL_NAME;
249var CONTENT_NAME = "TooltipContent";
250var TooltipContent = React.forwardRef(
251  (props, forwardedRef) => {
252    const portalContext = usePortalContext(CONTENT_NAME, props.__scopeTooltip);
253    const { forceMount = portalContext.forceMount, side = "top", ...contentProps } = props;
254    const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
255    return (0, import_jsx_runtime.jsx)(Presence, { present: forceMount || context.open, children: context.disableHoverableContent ? (0, import_jsx_runtime.jsx)(TooltipContentImpl, { side, ...contentProps, ref: forwardedRef }) : (0, import_jsx_runtime.jsx)(TooltipContentHoverable, { side, ...contentProps, ref: forwardedRef }) });
256  }
257);
258var TooltipContentHoverable = React.forwardRef((props, forwardedRef) => {
259  const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
260  const providerContext = useTooltipProviderContext(CONTENT_NAME, props.__scopeTooltip);
261  const ref = React.useRef(null);
262  const composedRefs = useComposedRefs(forwardedRef, ref);
263  const [pointerGraceArea, setPointerGraceArea] = React.useState(null);
264  const { trigger, onClose } = context;
265  const content = ref.current;
266  const { onPointerInTransitChange } = providerContext;
267  const handleRemoveGraceArea = React.useCallback(() => {
268    setPointerGraceArea(null);
269    onPointerInTransitChange(false);
270  }, [onPointerInTransitChange]);
271  const handleCreateGraceArea = React.useCallback(
272    (event, hoverTarget) => {
273      const currentTarget = event.currentTarget;
274      const exitPoint = { x: event.clientX, y: event.clientY };
275      const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
276      const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);
277      const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
278      const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
279      setPointerGraceArea(graceArea);
280      onPointerInTransitChange(true);
281    },
282    [onPointerInTransitChange]
283  );
284  React.useEffect(() => {
285    return () => handleRemoveGraceArea();
286  }, [handleRemoveGraceArea]);
287  React.useEffect(() => {
288    if (trigger && content) {
289      const handleTriggerLeave = (event) => handleCreateGraceArea(event, content);
290      const handleContentLeave = (event) => handleCreateGraceArea(event, trigger);
291      trigger.addEventListener("pointerleave", handleTriggerLeave);
292      content.addEventListener("pointerleave", handleContentLeave);
293      return () => {
294        trigger.removeEventListener("pointerleave", handleTriggerLeave);
295        content.removeEventListener("pointerleave", handleContentLeave);
296      };
297    }
298  }, [trigger, content, handleCreateGraceArea, handleRemoveGraceArea]);
299  React.useEffect(() => {
300    if (pointerGraceArea) {
301      const handleTrackPointerGrace = (event) => {
302        const target = event.target;
303        const pointerPosition = { x: event.clientX, y: event.clientY };
304        const hasEnteredTarget = (trigger == null ? void 0 : trigger.contains(target)) || (content == null ? void 0 : content.contains(target));
305        const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea);
306        if (hasEnteredTarget) {
307          handleRemoveGraceArea();
308        } else if (isPointerOutsideGraceArea) {
309          handleRemoveGraceArea();
310          onClose();
311        }
312      };
313      document.addEventListener("pointermove", handleTrackPointerGrace);
314      return () => document.removeEventListener("pointermove", handleTrackPointerGrace);
315    }
316  }, [trigger, content, pointerGraceArea, onClose, handleRemoveGraceArea]);
317  return (0, import_jsx_runtime.jsx)(TooltipContentImpl, { ...props, ref: composedRefs });
318});
319var [VisuallyHiddenContentContextProvider, useVisuallyHiddenContentContext] = createTooltipContext(TOOLTIP_NAME, { isInside: false });
320var Slottable = createSlottable("TooltipContent");
321var TooltipContentImpl = React.forwardRef(
322  (props, forwardedRef) => {
323    const {
324      __scopeTooltip,
325      children,
326      "aria-label": ariaLabel,
327      onEscapeKeyDown,
328      onPointerDownOutside,
329      ...contentProps
330    } = props;
331    const context = useTooltipContext(CONTENT_NAME, __scopeTooltip);
332    const popperScope = usePopperScope(__scopeTooltip);
333    const { onClose } = context;
334    React.useEffect(() => {
335      document.addEventListener(TOOLTIP_OPEN, onClose);
336      return () => document.removeEventListener(TOOLTIP_OPEN, onClose);
337    }, [onClose]);
338    React.useEffect(() => {
339      if (context.trigger) {
340        const handleScroll = (event) => {
341          const target = event.target;
342          if (target == null ? void 0 : target.contains(context.trigger)) onClose();
343        };
344        window.addEventListener("scroll", handleScroll, { capture: true });
345        return () => window.removeEventListener("scroll", handleScroll, { capture: true });
346      }
347    }, [context.trigger, onClose]);
348    return (0, import_jsx_runtime.jsx)(
349      DismissableLayer,
350      {
351        asChild: true,
352        disableOutsidePointerEvents: false,
353        onEscapeKeyDown,
354        onPointerDownOutside,
355        onFocusOutside: (event) => event.preventDefault(),
356        onDismiss: onClose,
357        children: (0, import_jsx_runtime.jsxs)(
358          Content,
359          {
360            "data-state": context.stateAttribute,
361            ...popperScope,
362            ...contentProps,
363            ref: forwardedRef,
364            style: {
365              ...contentProps.style,
366              // re-namespace exposed content custom properties
367              ...{
368                "--radix-tooltip-content-transform-origin": "var(--radix-popper-transform-origin)",
369                "--radix-tooltip-content-available-width": "var(--radix-popper-available-width)",
370                "--radix-tooltip-content-available-height": "var(--radix-popper-available-height)",
371                "--radix-tooltip-trigger-width": "var(--radix-popper-anchor-width)",
372                "--radix-tooltip-trigger-height": "var(--radix-popper-anchor-height)"
373              }
374            },
375            children: [
376              (0, import_jsx_runtime.jsx)(Slottable, { children }),
377              (0, import_jsx_runtime.jsx)(VisuallyHiddenContentContextProvider, { scope: __scopeTooltip, isInside: true, children: (0, import_jsx_runtime.jsx)(Root, { id: context.contentId, role: "tooltip", children: ariaLabel || children }) })
378            ]
379          }
380        )
381      }
382    );
383  }
384);
385TooltipContent.displayName = CONTENT_NAME;
386var ARROW_NAME = "TooltipArrow";
387var TooltipArrow = React.forwardRef(
388  (props, forwardedRef) => {
389    const { __scopeTooltip, ...arrowProps } = props;
390    const popperScope = usePopperScope(__scopeTooltip);
391    const visuallyHiddenContentContext = useVisuallyHiddenContentContext(
392      ARROW_NAME,
393      __scopeTooltip
394    );
395    return visuallyHiddenContentContext.isInside ? null : (0, import_jsx_runtime.jsx)(Arrow, { ...popperScope, ...arrowProps, ref: forwardedRef });
396  }
397);
398TooltipArrow.displayName = ARROW_NAME;
399function getExitSideFromRect(point, rect) {
400  const top = Math.abs(rect.top - point.y);
401  const bottom = Math.abs(rect.bottom - point.y);
402  const right = Math.abs(rect.right - point.x);
403  const left = Math.abs(rect.left - point.x);
404  switch (Math.min(top, bottom, right, left)) {
405    case left:
406      return "left";
407    case right:
408      return "right";
409    case top:
410      return "top";
411    case bottom:
412      return "bottom";
413    default:
414      throw new Error("unreachable");
415  }
416}
417function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
418  const paddedExitPoints = [];
419  switch (exitSide) {
420    case "top":
421      paddedExitPoints.push(
422        { x: exitPoint.x - padding, y: exitPoint.y + padding },
423        { x: exitPoint.x + padding, y: exitPoint.y + padding }
424      );
425      break;
426    case "bottom":
427      paddedExitPoints.push(
428        { x: exitPoint.x - padding, y: exitPoint.y - padding },
429        { x: exitPoint.x + padding, y: exitPoint.y - padding }
430      );
431      break;
432    case "left":
433      paddedExitPoints.push(
434        { x: exitPoint.x + padding, y: exitPoint.y - padding },
435        { x: exitPoint.x + padding, y: exitPoint.y + padding }
436      );
437      break;
438    case "right":
439      paddedExitPoints.push(
440        { x: exitPoint.x - padding, y: exitPoint.y - padding },
441        { x: exitPoint.x - padding, y: exitPoint.y + padding }
442      );
443      break;
444  }
445  return paddedExitPoints;
446}
447function getPointsFromRect(rect) {
448  const { top, right, bottom, left } = rect;
449  return [
450    { x: left, y: top },
451    { x: right, y: top },
452    { x: right, y: bottom },
453    { x: left, y: bottom }
454  ];
455}
456function isPointInPolygon(point, polygon) {
457  const { x, y } = point;
458  let inside = false;
459  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
460    const ii = polygon[i];
461    const jj = polygon[j];
462    const xi = ii.x;
463    const yi = ii.y;
464    const xj = jj.x;
465    const yj = jj.y;
466    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
467    if (intersect) inside = !inside;
468  }
469  return inside;
470}
471function getHull(points) {
472  const newPoints = points.slice();
473  newPoints.sort((a, b) => {
474    if (a.x < b.x) return -1;
475    else if (a.x > b.x) return 1;
476    else if (a.y < b.y) return -1;
477    else if (a.y > b.y) return 1;
478    else return 0;
479  });
480  return getHullPresorted(newPoints);
481}
482function getHullPresorted(points) {
483  if (points.length <= 1) return points.slice();
484  const upperHull = [];
485  for (let i = 0; i < points.length; i++) {
486    const p = points[i];
487    while (upperHull.length >= 2) {
488      const q = upperHull[upperHull.length - 1];
489      const r = upperHull[upperHull.length - 2];
490      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) upperHull.pop();
491      else break;
492    }
493    upperHull.push(p);
494  }
495  upperHull.pop();
496  const lowerHull = [];
497  for (let i = points.length - 1; i >= 0; i--) {
498    const p = points[i];
499    while (lowerHull.length >= 2) {
500      const q = lowerHull[lowerHull.length - 1];
501      const r = lowerHull[lowerHull.length - 2];
502      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) lowerHull.pop();
503      else break;
504    }
505    lowerHull.push(p);
506  }
507  lowerHull.pop();
508  if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y) {
509    return upperHull;
510  } else {
511    return upperHull.concat(lowerHull);
512  }
513}
514var Provider = TooltipProvider;
515var Root3 = Tooltip;
516var Trigger = TooltipTrigger;
517var Portal2 = TooltipPortal;
518var Content2 = TooltipContent;
519var Arrow2 = TooltipArrow;
520export {
521  Arrow2 as Arrow,
522  Content2 as Content,
523  Portal2 as Portal,
524  Provider,
525  Root3 as Root,
526  Tooltip,
527  TooltipArrow,
528  TooltipContent,
529  TooltipPortal,
530  TooltipProvider,
531  TooltipTrigger,
532  Trigger,
533  createTooltipScope
534};
535//# sourceMappingURL=@radix-ui_react-tooltip.js.map