@adam-milo/ui 1.0.32 → 1.0.34

package/dist/index6.js

@@ -1,112 +1,22 @@
 import { jsx } from "react/jsx-runtime";
-import { forwardRef, useRef, useMemo, useCallback, useState, useEffect } from "react";
-import { Input } from "./index24.js";
-import { useMergedRef } from "./index25.js";
-const AlphanumericInput = forwardRef(
-  ({
-    allowHyphen = false,
-    allowUnderscore = false,
-    allowSpace = false,
-    minLength,
-    maxLength,
-    validate,
-    onChange,
-    "data-cy": dataCy,
-    "data-testid": dataTestId,
-    ...props
-  }, ref) => {
-    const inputRef = useRef(null);
-    const mergedRef = useMergedRef(ref, inputRef);
-    const alphanumericRegex = useMemo(() => {
-      let pattern = "^[a-zA-Z0-9";
-      if (allowHyphen) pattern += "\\-";
-      if (allowUnderscore) pattern += "_";
-      if (allowSpace) pattern += " ";
-      pattern += "]*$";
-      return new RegExp(pattern);
-    }, [allowHyphen, allowUnderscore, allowSpace]);
-    const characterRegex = useMemo(() => {
-      let pattern = "[a-zA-Z0-9";
-      if (allowHyphen) pattern += "\\-";
-      if (allowUnderscore) pattern += "_";
-      if (allowSpace) pattern += " ";
-      pattern += "]";
-      return new RegExp(pattern);
-    }, [allowHyphen, allowUnderscore, allowSpace]);
-    const alphanumericValidation = useCallback(
-      (value) => {
-        if (!value) return void 0;
-        if (!alphanumericRegex.test(value)) {
-          let allowedChars = "letters and numbers";
-          const extras = [];
-          if (allowHyphen) extras.push("hyphens");
-          if (allowUnderscore) extras.push("underscores");
-          if (allowSpace) extras.push("spaces");
-          if (extras.length > 0) {
-            allowedChars += `, ${extras.join(", ")}`;
-          }
-          return `Only ${allowedChars} are allowed`;
-        }
-        if (minLength !== void 0 && value.length < minLength) {
-          return `Must be at least ${minLength} characters`;
-        }
-        if (maxLength !== void 0 && value.length > maxLength) {
-          return `Must be at most ${maxLength} characters`;
-        }
-        return void 0;
-      },
-      [alphanumericRegex, minLength, maxLength, allowHyphen, allowUnderscore, allowSpace]
-    );
-    const combinedValidation = useCallback(
-      (value) => {
-        if (!validate) return alphanumericValidation(value);
-        return alphanumericValidation(value) || validate(value);
-      },
-      [alphanumericValidation, validate]
-    );
-    const [pendingCursorPosition, setPendingCursorPosition] = useState(null);
-    useEffect(() => {
-      if (pendingCursorPosition !== null && inputRef.current) {
-        inputRef.current.setSelectionRange(pendingCursorPosition, pendingCursorPosition);
-        setPendingCursorPosition(null);
-      }
-    }, [props.value, pendingCursorPosition]);
-    const handleChange = useCallback(
-      (e) => {
-        const input = e.target;
-        const value = input.value;
-        const cursorPosition = input.selectionStart || 0;
-        const filteredValue = value.split("").filter((char) => characterRegex.test(char)).join("");
-        const removedBeforeCursor = value.slice(0, cursorPosition).split("").filter((char) => !characterRegex.test(char)).length;
-        const newPosition = cursorPosition - removedBeforeCursor;
-        input.value = filteredValue;
-        const isControlled = props.value !== void 0;
-        if (isControlled) {
-          setPendingCursorPosition(newPosition);
-        } else {
-          input.setSelectionRange(newPosition, newPosition);
-        }
-        onChange == null ? void 0 : onChange(e);
-      },
-      [characterRegex, onChange, props.value]
-    );
+import { forwardRef } from "react";
+import { Input } from "./index36.js";
+const PasswordInput = forwardRef(
+  ({ showToggle = true, "data-cy": dataCy, "data-testid": dataTestId, ...props }, ref) => {
     return /* @__PURE__ */ jsx(
       Input,
       {
-        ref: mergedRef,
-        type: "text",
-        minLength,
-        maxLength,
-        validate: combinedValidation,
-        onChange: handleChange,
-        "data-cy": dataCy || "alphanumeric-input",
-        "data-testid": dataTestId || "alphanumeric-input",
+        ref,
+        type: "password",
+        showPasswordToggle: showToggle,
+        "data-cy": dataCy || "password-input",
+        "data-testid": dataTestId || "password-input",
         ...props
       }
     );
   }
 );
-AlphanumericInput.displayName = "AlphanumericInput";
+PasswordInput.displayName = "PasswordInput";
 export {
-  AlphanumericInput
+  PasswordInput
 };

package/dist/index62.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react"),t=require("./index64.cjs"),r=require("./index65.cjs"),o=require("./index66.cjs"),n=require("./index67.cjs"),i=require("./index68.cjs"),s=require("./index69.cjs"),c=require("./index70.cjs"),a=require("./index71.cjs"),l=require("./index72.cjs"),u=require("./index73.cjs"),p=require("./index74.cjs"),d=require("./index75.cjs"),x=require("react/jsx-runtime");function f(e){const t=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e)for(const r in e)if("default"!==r){const o=Object.getOwnPropertyDescriptor(e,r);Object.defineProperty(t,r,o.get?o:{enumerable:!0,get:()=>e[r]})}return t.default=e,Object.freeze(t)}const g=f(e);var[h]=o.createContextScope("Tooltip",[s.createPopperScope]),v=s.createPopperScope(),y="TooltipProvider",b=700,m="tooltip.open",[T,w]=h(y),C=e=>{const{__scopeTooltip:t,delayDuration:r=b,skipDelayDuration:o=300,disableHoverableContent:n=!1,children:i}=e,s=g.useRef(!0),c=g.useRef(!1),a=g.useRef(0);return g.useEffect(()=>{const e=a.current;return()=>window.clearTimeout(e)},[]),x.jsx(T,{scope:t,isOpenDelayedRef:s,delayDuration:r,onOpen:g.useCallback(()=>{window.clearTimeout(a.current),s.current=!1},[]),onClose:g.useCallback(()=>{window.clearTimeout(a.current),a.current=window.setTimeout(()=>s.current=!0,o)},[o]),isPointerInTransitRef:c,onPointerInTransitChange:g.useCallback(e=>{c.current=e},[]),disableHoverableContent:n,children:i})};C.displayName=y;var j="Tooltip",[E,P]=h(j),R=e=>{const{__scopeTooltip:t,children:r,open:o,defaultOpen:n,onOpenChange:c,disableHoverableContent:a,delayDuration:l}=e,u=w(j,e.__scopeTooltip),d=v(t),[f,h]=g.useState(null),y=i.useId(),b=g.useRef(0),T=a??u.disableHoverableContent,C=l??u.delayDuration,P=g.useRef(!1),[R,_]=p.useControllableState({prop:o,defaultProp:n??!1,onChange:e=>{e?(u.onOpen(),document.dispatchEvent(new CustomEvent(m))):u.onClose(),null==c||c(e)},caller:j}),k=g.useMemo(()=>R?P.current?"delayed-open":"instant-open":"closed",[R]),D=g.useCallback(()=>{window.clearTimeout(b.current),b.current=0,P.current=!1,_(!0)},[_]),O=g.useCallback(()=>{window.clearTimeout(b.current),b.current=0,_(!1)},[_]),L=g.useCallback(()=>{window.clearTimeout(b.current),b.current=window.setTimeout(()=>{P.current=!0,_(!0),b.current=0},C)},[C,_]);return g.useEffect(()=>()=>{b.current&&(window.clearTimeout(b.current),b.current=0)},[]),x.jsx(s.Root,{...d,children:x.jsx(E,{scope:t,contentId:y,open:R,stateAttribute:k,trigger:f,onTriggerChange:h,onTriggerEnter:g.useCallback(()=>{u.isOpenDelayedRef.current?L():D()},[u.isOpenDelayedRef,L,D]),onTriggerLeave:g.useCallback(()=>{T?O():(window.clearTimeout(b.current),b.current=0)},[O,T]),onOpen:D,onClose:O,disableHoverableContent:T,children:r})})};R.displayName=j;var _="TooltipTrigger",k=g.forwardRef((e,o)=>{const{__scopeTooltip:n,...i}=e,c=P(_,n),a=w(_,n),u=v(n),p=g.useRef(null),d=r.useComposedRefs(o,p,c.onTriggerChange),f=g.useRef(!1),h=g.useRef(!1),y=g.useCallback(()=>f.current=!1,[]);return g.useEffect(()=>()=>document.removeEventListener("pointerup",y),[y]),x.jsx(s.Anchor,{asChild:!0,...u,children:x.jsx(l.Primitive.button,{"aria-describedby":c.open?c.contentId:void 0,"data-state":c.stateAttribute,...i,ref:d,onPointerMove:t.composeEventHandlers(e.onPointerMove,e=>{"touch"!==e.pointerType&&(h.current||a.isPointerInTransitRef.current||(c.onTriggerEnter(),h.current=!0))}),onPointerLeave:t.composeEventHandlers(e.onPointerLeave,()=>{c.onTriggerLeave(),h.current=!1}),onPointerDown:t.composeEventHandlers(e.onPointerDown,()=>{c.open&&c.onClose(),f.current=!0,document.addEventListener("pointerup",y,{once:!0})}),onFocus:t.composeEventHandlers(e.onFocus,()=>{f.current||c.onOpen()}),onBlur:t.composeEventHandlers(e.onBlur,c.onClose),onClick:t.composeEventHandlers(e.onClick,c.onClose)})})});k.displayName=_;var D="TooltipPortal",[O,L]=h(D,{forceMount:void 0}),M=e=>{const{__scopeTooltip:t,forceMount:r,children:o,container:n}=e,i=P(D,t);return x.jsx(O,{scope:t,forceMount:r,children:x.jsx(a.Presence,{present:r||i.open,children:x.jsx(c.Portal,{asChild:!0,container:n,children:o})})})};M.displayName=D;var q="TooltipContent",H=g.forwardRef((e,t)=>{const r=L(q,e.__scopeTooltip),{forceMount:o=r.forceMount,side:n="top",...i}=e,s=P(q,e.__scopeTooltip);return x.jsx(a.Presence,{present:o||s.open,children:s.disableHoverableContent?x.jsx(B,{side:n,...i,ref:t}):x.jsx(I,{side:n,...i,ref:t})})}),I=g.forwardRef((e,t)=>{const o=P(q,e.__scopeTooltip),n=w(q,e.__scopeTooltip),i=g.useRef(null),s=r.useComposedRefs(t,i),[c,a]=g.useState(null),{trigger:l,onClose:u}=o,p=i.current,{onPointerInTransitChange:d}=n,f=g.useCallback(()=>{a(null),d(!1)},[d]),h=g.useCallback((e,t)=>{const r=e.currentTarget,o={x:e.clientX,y:e.clientY},n=function(e,t,r=5){const o=[];switch(t){case"top":o.push({x:e.x-r,y:e.y+r},{x:e.x+r,y:e.y+r});break;case"bottom":o.push({x:e.x-r,y:e.y-r},{x:e.x+r,y:e.y-r});break;case"left":o.push({x:e.x+r,y:e.y-r},{x:e.x+r,y:e.y+r});break;case"right":o.push({x:e.x-r,y:e.y-r},{x:e.x-r,y:e.y+r})}return o}(o,function(e,t){const r=Math.abs(t.top-e.y),o=Math.abs(t.bottom-e.y),n=Math.abs(t.right-e.x),i=Math.abs(t.left-e.x);switch(Math.min(r,o,n,i)){case i:return"left";case n:return"right";case r:return"top";case o:return"bottom";default:throw new Error("unreachable")}}(o,r.getBoundingClientRect())),i=function(e){const t=e.slice();return t.sort((e,t)=>e.x<t.x?-1:e.x>t.x?1:e.y<t.y?-1:e.y>t.y?1:0),function(e){if(e.length<=1)return e.slice();const t=[];for(let o=0;o<e.length;o++){const r=e[o];for(;t.length>=2;){const e=t[t.length-1],o=t[t.length-2];if(!((e.x-o.x)*(r.y-o.y)>=(e.y-o.y)*(r.x-o.x)))break;t.pop()}t.push(r)}t.pop();const r=[];for(let o=e.length-1;o>=0;o--){const t=e[o];for(;r.length>=2;){const e=r[r.length-1],o=r[r.length-2];if(!((e.x-o.x)*(t.y-o.y)>=(e.y-o.y)*(t.x-o.x)))break;r.pop()}r.push(t)}return r.pop(),1===t.length&&1===r.length&&t[0].x===r[0].x&&t[0].y===r[0].y?t:t.concat(r)}(t)}([...n,...function(e){const{top:t,right:r,bottom:o,left:n}=e;return[{x:n,y:t},{x:r,y:t},{x:r,y:o},{x:n,y:o}]}(t.getBoundingClientRect())]);a(i),d(!0)},[d]);return g.useEffect(()=>()=>f(),[f]),g.useEffect(()=>{if(l&&p){const e=e=>h(e,p),t=e=>h(e,l);return l.addEventListener("pointerleave",e),p.addEventListener("pointerleave",t),()=>{l.removeEventListener("pointerleave",e),p.removeEventListener("pointerleave",t)}}},[l,p,h,f]),g.useEffect(()=>{if(c){const e=e=>{const t=e.target,r={x:e.clientX,y:e.clientY},o=(null==l?void 0:l.contains(t))||(null==p?void 0:p.contains(t)),n=!function(e,t){const{x:r,y:o}=e;let n=!1;for(let i=0,s=t.length-1;i<t.length;s=i++){const e=t[i],c=t[s],a=e.x,l=e.y,u=c.x,p=c.y;l>o!=p>o&&r<(u-a)*(o-l)/(p-l)+a&&(n=!n)}return n}(r,c);o?f():n&&(f(),u())};return document.addEventListener("pointermove",e),()=>document.removeEventListener("pointermove",e)}},[l,p,c,u,f]),x.jsx(B,{...e,ref:s})}),[S,A]=h(j,{isInside:!1}),N=u.createSlottable("TooltipContent"),B=g.forwardRef((e,t)=>{const{__scopeTooltip:r,children:o,"aria-label":i,onEscapeKeyDown:c,onPointerDownOutside:a,...l}=e,u=P(q,r),p=v(r),{onClose:f}=u;return g.useEffect(()=>(document.addEventListener(m,f),()=>document.removeEventListener(m,f)),[f]),g.useEffect(()=>{if(u.trigger){const e=e=>{const t=e.target;(null==t?void 0:t.contains(u.trigger))&&f()};return window.addEventListener("scroll",e,{capture:!0}),()=>window.removeEventListener("scroll",e,{capture:!0})}},[u.trigger,f]),x.jsx(n.DismissableLayer,{asChild:!0,disableOutsidePointerEvents:!1,onEscapeKeyDown:c,onPointerDownOutside:a,onFocusOutside:e=>e.preventDefault(),onDismiss:f,children:x.jsxs(s.Content,{"data-state":u.stateAttribute,...p,...l,ref:t,style:{...l.style,"--radix-tooltip-content-transform-origin":"var(--radix-popper-transform-origin)","--radix-tooltip-content-available-width":"var(--radix-popper-available-width)","--radix-tooltip-content-available-height":"var(--radix-popper-available-height)","--radix-tooltip-trigger-width":"var(--radix-popper-anchor-width)","--radix-tooltip-trigger-height":"var(--radix-popper-anchor-height)"},children:[x.jsx(N,{children:o}),x.jsx(S,{scope:r,isInside:!0,children:x.jsx(d.Root,{id:u.contentId,role:"tooltip",children:i||o})})]})})});H.displayName=q;var F="TooltipArrow",K=g.forwardRef((e,t)=>{const{__scopeTooltip:r,...o}=e,n=v(r);return A(F,r).isInside?null:x.jsx(s.Arrow,{...n,...o,ref:t})});K.displayName=F;var X=C,Y=R,z=k,G=M,J=H,Q=K;exports.Arrow=Q,exports.Content=J,exports.Portal=G,exports.Provider=X,exports.Root=Y,exports.Tooltip=R,exports.TooltipArrow=K,exports.TooltipContent=H,exports.TooltipPortal=M,exports.TooltipProvider=C,exports.TooltipTrigger=k,exports.Trigger=z;

package/dist/index62.js

@@ -0,0 +1,502 @@
+import * as React from "react";
+import { composeEventHandlers } from "./index64.js";
+import { useComposedRefs } from "./index65.js";
+import { createContextScope } from "./index66.js";
+import { DismissableLayer } from "./index67.js";
+import { useId } from "./index68.js";
+import { createPopperScope, Root as Root2, Anchor, Arrow, Content } from "./index69.js";
+import { Portal as Portal$1 } from "./index70.js";
+import { Presence } from "./index71.js";
+import { Primitive } from "./index72.js";
+import { createSlottable } from "./index73.js";
+import { useControllableState } from "./index74.js";
+import { Root } from "./index75.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+var [createTooltipContext] = createContextScope("Tooltip", [
+  createPopperScope
+]);
+var usePopperScope = createPopperScope();
+var PROVIDER_NAME = "TooltipProvider";
+var DEFAULT_DELAY_DURATION = 700;
+var TOOLTIP_OPEN = "tooltip.open";
+var [TooltipProviderContextProvider, useTooltipProviderContext] = createTooltipContext(PROVIDER_NAME);
+var TooltipProvider = (props) => {
+  const {
+    __scopeTooltip,
+    delayDuration = DEFAULT_DELAY_DURATION,
+    skipDelayDuration = 300,
+    disableHoverableContent = false,
+    children
+  } = props;
+  const isOpenDelayedRef = React.useRef(true);
+  const isPointerInTransitRef = React.useRef(false);
+  const skipDelayTimerRef = React.useRef(0);
+  React.useEffect(() => {
+    const skipDelayTimer = skipDelayTimerRef.current;
+    return () => window.clearTimeout(skipDelayTimer);
+  }, []);
+  return /* @__PURE__ */ jsx(
+    TooltipProviderContextProvider,
+    {
+      scope: __scopeTooltip,
+      isOpenDelayedRef,
+      delayDuration,
+      onOpen: React.useCallback(() => {
+        window.clearTimeout(skipDelayTimerRef.current);
+        isOpenDelayedRef.current = false;
+      }, []),
+      onClose: React.useCallback(() => {
+        window.clearTimeout(skipDelayTimerRef.current);
+        skipDelayTimerRef.current = window.setTimeout(
+          () => isOpenDelayedRef.current = true,
+          skipDelayDuration
+        );
+      }, [skipDelayDuration]),
+      isPointerInTransitRef,
+      onPointerInTransitChange: React.useCallback((inTransit) => {
+        isPointerInTransitRef.current = inTransit;
+      }, []),
+      disableHoverableContent,
+      children
+    }
+  );
+};
+TooltipProvider.displayName = PROVIDER_NAME;
+var TOOLTIP_NAME = "Tooltip";
+var [TooltipContextProvider, useTooltipContext] = createTooltipContext(TOOLTIP_NAME);
+var Tooltip = (props) => {
+  const {
+    __scopeTooltip,
+    children,
+    open: openProp,
+    defaultOpen,
+    onOpenChange,
+    disableHoverableContent: disableHoverableContentProp,
+    delayDuration: delayDurationProp
+  } = props;
+  const providerContext = useTooltipProviderContext(TOOLTIP_NAME, props.__scopeTooltip);
+  const popperScope = usePopperScope(__scopeTooltip);
+  const [trigger, setTrigger] = React.useState(null);
+  const contentId = useId();
+  const openTimerRef = React.useRef(0);
+  const disableHoverableContent = disableHoverableContentProp ?? providerContext.disableHoverableContent;
+  const delayDuration = delayDurationProp ?? providerContext.delayDuration;
+  const wasOpenDelayedRef = React.useRef(false);
+  const [open, setOpen] = useControllableState({
+    prop: openProp,
+    defaultProp: defaultOpen ?? false,
+    onChange: (open2) => {
+      if (open2) {
+        providerContext.onOpen();
+        document.dispatchEvent(new CustomEvent(TOOLTIP_OPEN));
+      } else {
+        providerContext.onClose();
+      }
+      onOpenChange == null ? void 0 : onOpenChange(open2);
+    },
+    caller: TOOLTIP_NAME
+  });
+  const stateAttribute = React.useMemo(() => {
+    return open ? wasOpenDelayedRef.current ? "delayed-open" : "instant-open" : "closed";
+  }, [open]);
+  const handleOpen = React.useCallback(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = 0;
+    wasOpenDelayedRef.current = false;
+    setOpen(true);
+  }, [setOpen]);
+  const handleClose = React.useCallback(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = 0;
+    setOpen(false);
+  }, [setOpen]);
+  const handleDelayedOpen = React.useCallback(() => {
+    window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = window.setTimeout(() => {
+      wasOpenDelayedRef.current = true;
+      setOpen(true);
+      openTimerRef.current = 0;
+    }, delayDuration);
+  }, [delayDuration, setOpen]);
+  React.useEffect(() => {
+    return () => {
+      if (openTimerRef.current) {
+        window.clearTimeout(openTimerRef.current);
+        openTimerRef.current = 0;
+      }
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(Root2, { ...popperScope, children: /* @__PURE__ */ jsx(
+    TooltipContextProvider,
+    {
+      scope: __scopeTooltip,
+      contentId,
+      open,
+      stateAttribute,
+      trigger,
+      onTriggerChange: setTrigger,
+      onTriggerEnter: React.useCallback(() => {
+        if (providerContext.isOpenDelayedRef.current) handleDelayedOpen();
+        else handleOpen();
+      }, [providerContext.isOpenDelayedRef, handleDelayedOpen, handleOpen]),
+      onTriggerLeave: React.useCallback(() => {
+        if (disableHoverableContent) {
+          handleClose();
+        } else {
+          window.clearTimeout(openTimerRef.current);
+          openTimerRef.current = 0;
+        }
+      }, [handleClose, disableHoverableContent]),
+      onOpen: handleOpen,
+      onClose: handleClose,
+      disableHoverableContent,
+      children
+    }
+  ) });
+};
+Tooltip.displayName = TOOLTIP_NAME;
+var TRIGGER_NAME = "TooltipTrigger";
+var TooltipTrigger = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeTooltip, ...triggerProps } = props;
+    const context = useTooltipContext(TRIGGER_NAME, __scopeTooltip);
+    const providerContext = useTooltipProviderContext(TRIGGER_NAME, __scopeTooltip);
+    const popperScope = usePopperScope(__scopeTooltip);
+    const ref = React.useRef(null);
+    const composedRefs = useComposedRefs(forwardedRef, ref, context.onTriggerChange);
+    const isPointerDownRef = React.useRef(false);
+    const hasPointerMoveOpenedRef = React.useRef(false);
+    const handlePointerUp = React.useCallback(() => isPointerDownRef.current = false, []);
+    React.useEffect(() => {
+      return () => document.removeEventListener("pointerup", handlePointerUp);
+    }, [handlePointerUp]);
+    return /* @__PURE__ */ jsx(Anchor, { asChild: true, ...popperScope, children: /* @__PURE__ */ jsx(
+      Primitive.button,
+      {
+        "aria-describedby": context.open ? context.contentId : void 0,
+        "data-state": context.stateAttribute,
+        ...triggerProps,
+        ref: composedRefs,
+        onPointerMove: composeEventHandlers(props.onPointerMove, (event) => {
+          if (event.pointerType === "touch") return;
+          if (!hasPointerMoveOpenedRef.current && !providerContext.isPointerInTransitRef.current) {
+            context.onTriggerEnter();
+            hasPointerMoveOpenedRef.current = true;
+          }
+        }),
+        onPointerLeave: composeEventHandlers(props.onPointerLeave, () => {
+          context.onTriggerLeave();
+          hasPointerMoveOpenedRef.current = false;
+        }),
+        onPointerDown: composeEventHandlers(props.onPointerDown, () => {
+          if (context.open) {
+            context.onClose();
+          }
+          isPointerDownRef.current = true;
+          document.addEventListener("pointerup", handlePointerUp, { once: true });
+        }),
+        onFocus: composeEventHandlers(props.onFocus, () => {
+          if (!isPointerDownRef.current) context.onOpen();
+        }),
+        onBlur: composeEventHandlers(props.onBlur, context.onClose),
+        onClick: composeEventHandlers(props.onClick, context.onClose)
+      }
+    ) });
+  }
+);
+TooltipTrigger.displayName = TRIGGER_NAME;
+var PORTAL_NAME = "TooltipPortal";
+var [PortalProvider, usePortalContext] = createTooltipContext(PORTAL_NAME, {
+  forceMount: void 0
+});
+var TooltipPortal = (props) => {
+  const { __scopeTooltip, forceMount, children, container } = props;
+  const context = useTooltipContext(PORTAL_NAME, __scopeTooltip);
+  return /* @__PURE__ */ jsx(PortalProvider, { scope: __scopeTooltip, forceMount, children: /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: /* @__PURE__ */ jsx(Portal$1, { asChild: true, container, children }) }) });
+};
+TooltipPortal.displayName = PORTAL_NAME;
+var CONTENT_NAME = "TooltipContent";
+var TooltipContent = React.forwardRef(
+  (props, forwardedRef) => {
+    const portalContext = usePortalContext(CONTENT_NAME, props.__scopeTooltip);
+    const { forceMount = portalContext.forceMount, side = "top", ...contentProps } = props;
+    const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
+    return /* @__PURE__ */ jsx(Presence, { present: forceMount || context.open, children: context.disableHoverableContent ? /* @__PURE__ */ jsx(TooltipContentImpl, { side, ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ jsx(TooltipContentHoverable, { side, ...contentProps, ref: forwardedRef }) });
+  }
+);
+var TooltipContentHoverable = React.forwardRef((props, forwardedRef) => {
+  const context = useTooltipContext(CONTENT_NAME, props.__scopeTooltip);
+  const providerContext = useTooltipProviderContext(CONTENT_NAME, props.__scopeTooltip);
+  const ref = React.useRef(null);
+  const composedRefs = useComposedRefs(forwardedRef, ref);
+  const [pointerGraceArea, setPointerGraceArea] = React.useState(null);
+  const { trigger, onClose } = context;
+  const content = ref.current;
+  const { onPointerInTransitChange } = providerContext;
+  const handleRemoveGraceArea = React.useCallback(() => {
+    setPointerGraceArea(null);
+    onPointerInTransitChange(false);
+  }, [onPointerInTransitChange]);
+  const handleCreateGraceArea = React.useCallback(
+    (event, hoverTarget) => {
+      const currentTarget = event.currentTarget;
+      const exitPoint = { x: event.clientX, y: event.clientY };
+      const exitSide = getExitSideFromRect(exitPoint, currentTarget.getBoundingClientRect());
+      const paddedExitPoints = getPaddedExitPoints(exitPoint, exitSide);
+      const hoverTargetPoints = getPointsFromRect(hoverTarget.getBoundingClientRect());
+      const graceArea = getHull([...paddedExitPoints, ...hoverTargetPoints]);
+      setPointerGraceArea(graceArea);
+      onPointerInTransitChange(true);
+    },
+    [onPointerInTransitChange]
+  );
+  React.useEffect(() => {
+    return () => handleRemoveGraceArea();
+  }, [handleRemoveGraceArea]);
+  React.useEffect(() => {
+    if (trigger && content) {
+      const handleTriggerLeave = (event) => handleCreateGraceArea(event, content);
+      const handleContentLeave = (event) => handleCreateGraceArea(event, trigger);
+      trigger.addEventListener("pointerleave", handleTriggerLeave);
+      content.addEventListener("pointerleave", handleContentLeave);
+      return () => {
+        trigger.removeEventListener("pointerleave", handleTriggerLeave);
+        content.removeEventListener("pointerleave", handleContentLeave);
+      };
+    }
+  }, [trigger, content, handleCreateGraceArea, handleRemoveGraceArea]);
+  React.useEffect(() => {
+    if (pointerGraceArea) {
+      const handleTrackPointerGrace = (event) => {
+        const target = event.target;
+        const pointerPosition = { x: event.clientX, y: event.clientY };
+        const hasEnteredTarget = (trigger == null ? void 0 : trigger.contains(target)) || (content == null ? void 0 : content.contains(target));
+        const isPointerOutsideGraceArea = !isPointInPolygon(pointerPosition, pointerGraceArea);
+        if (hasEnteredTarget) {
+          handleRemoveGraceArea();
+        } else if (isPointerOutsideGraceArea) {
+          handleRemoveGraceArea();
+          onClose();
+        }
+      };
+      document.addEventListener("pointermove", handleTrackPointerGrace);
+      return () => document.removeEventListener("pointermove", handleTrackPointerGrace);
+    }
+  }, [trigger, content, pointerGraceArea, onClose, handleRemoveGraceArea]);
+  return /* @__PURE__ */ jsx(TooltipContentImpl, { ...props, ref: composedRefs });
+});
+var [VisuallyHiddenContentContextProvider, useVisuallyHiddenContentContext] = createTooltipContext(TOOLTIP_NAME, { isInside: false });
+var Slottable = createSlottable("TooltipContent");
+var TooltipContentImpl = React.forwardRef(
+  (props, forwardedRef) => {
+    const {
+      __scopeTooltip,
+      children,
+      "aria-label": ariaLabel,
+      onEscapeKeyDown,
+      onPointerDownOutside,
+      ...contentProps
+    } = props;
+    const context = useTooltipContext(CONTENT_NAME, __scopeTooltip);
+    const popperScope = usePopperScope(__scopeTooltip);
+    const { onClose } = context;
+    React.useEffect(() => {
+      document.addEventListener(TOOLTIP_OPEN, onClose);
+      return () => document.removeEventListener(TOOLTIP_OPEN, onClose);
+    }, [onClose]);
+    React.useEffect(() => {
+      if (context.trigger) {
+        const handleScroll = (event) => {
+          const target = event.target;
+          if (target == null ? void 0 : target.contains(context.trigger)) onClose();
+        };
+        window.addEventListener("scroll", handleScroll, { capture: true });
+        return () => window.removeEventListener("scroll", handleScroll, { capture: true });
+      }
+    }, [context.trigger, onClose]);
+    return /* @__PURE__ */ jsx(
+      DismissableLayer,
+      {
+        asChild: true,
+        disableOutsidePointerEvents: false,
+        onEscapeKeyDown,
+        onPointerDownOutside,
+        onFocusOutside: (event) => event.preventDefault(),
+        onDismiss: onClose,
+        children: /* @__PURE__ */ jsxs(
+          Content,
+          {
+            "data-state": context.stateAttribute,
+            ...popperScope,
+            ...contentProps,
+            ref: forwardedRef,
+            style: {
+              ...contentProps.style,
+              // re-namespace exposed content custom properties
+              ...{
+                "--radix-tooltip-content-transform-origin": "var(--radix-popper-transform-origin)",
+                "--radix-tooltip-content-available-width": "var(--radix-popper-available-width)",
+                "--radix-tooltip-content-available-height": "var(--radix-popper-available-height)",
+                "--radix-tooltip-trigger-width": "var(--radix-popper-anchor-width)",
+                "--radix-tooltip-trigger-height": "var(--radix-popper-anchor-height)"
+              }
+            },
+            children: [
+              /* @__PURE__ */ jsx(Slottable, { children }),
+              /* @__PURE__ */ jsx(VisuallyHiddenContentContextProvider, { scope: __scopeTooltip, isInside: true, children: /* @__PURE__ */ jsx(Root, { id: context.contentId, role: "tooltip", children: ariaLabel || children }) })
+            ]
+          }
+        )
+      }
+    );
+  }
+);
+TooltipContent.displayName = CONTENT_NAME;
+var ARROW_NAME = "TooltipArrow";
+var TooltipArrow = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeTooltip, ...arrowProps } = props;
+    const popperScope = usePopperScope(__scopeTooltip);
+    const visuallyHiddenContentContext = useVisuallyHiddenContentContext(
+      ARROW_NAME,
+      __scopeTooltip
+    );
+    return visuallyHiddenContentContext.isInside ? null : /* @__PURE__ */ jsx(Arrow, { ...popperScope, ...arrowProps, ref: forwardedRef });
+  }
+);
+TooltipArrow.displayName = ARROW_NAME;
+function getExitSideFromRect(point, rect) {
+  const top = Math.abs(rect.top - point.y);
+  const bottom = Math.abs(rect.bottom - point.y);
+  const right = Math.abs(rect.right - point.x);
+  const left = Math.abs(rect.left - point.x);
+  switch (Math.min(top, bottom, right, left)) {
+    case left:
+      return "left";
+    case right:
+      return "right";
+    case top:
+      return "top";
+    case bottom:
+      return "bottom";
+    default:
+      throw new Error("unreachable");
+  }
+}
+function getPaddedExitPoints(exitPoint, exitSide, padding = 5) {
+  const paddedExitPoints = [];
+  switch (exitSide) {
+    case "top":
+      paddedExitPoints.push(
+        { x: exitPoint.x - padding, y: exitPoint.y + padding },
+        { x: exitPoint.x + padding, y: exitPoint.y + padding }
+      );
+      break;
+    case "bottom":
+      paddedExitPoints.push(
+        { x: exitPoint.x - padding, y: exitPoint.y - padding },
+        { x: exitPoint.x + padding, y: exitPoint.y - padding }
+      );
+      break;
+    case "left":
+      paddedExitPoints.push(
+        { x: exitPoint.x + padding, y: exitPoint.y - padding },
+        { x: exitPoint.x + padding, y: exitPoint.y + padding }
+      );
+      break;
+    case "right":
+      paddedExitPoints.push(
+        { x: exitPoint.x - padding, y: exitPoint.y - padding },
+        { x: exitPoint.x - padding, y: exitPoint.y + padding }
+      );
+      break;
+  }
+  return paddedExitPoints;
+}
+function getPointsFromRect(rect) {
+  const { top, right, bottom, left } = rect;
+  return [
+    { x: left, y: top },
+    { x: right, y: top },
+    { x: right, y: bottom },
+    { x: left, y: bottom }
+  ];
+}
+function isPointInPolygon(point, polygon) {
+  const { x, y } = point;
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const ii = polygon[i];
+    const jj = polygon[j];
+    const xi = ii.x;
+    const yi = ii.y;
+    const xj = jj.x;
+    const yj = jj.y;
+    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+function getHull(points) {
+  const newPoints = points.slice();
+  newPoints.sort((a, b) => {
+    if (a.x < b.x) return -1;
+    else if (a.x > b.x) return 1;
+    else if (a.y < b.y) return -1;
+    else if (a.y > b.y) return 1;
+    else return 0;
+  });
+  return getHullPresorted(newPoints);
+}
+function getHullPresorted(points) {
+  if (points.length <= 1) return points.slice();
+  const upperHull = [];
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
+    while (upperHull.length >= 2) {
+      const q = upperHull[upperHull.length - 1];
+      const r = upperHull[upperHull.length - 2];
+      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) upperHull.pop();
+      else break;
+    }
+    upperHull.push(p);
+  }
+  upperHull.pop();
+  const lowerHull = [];
+  for (let i = points.length - 1; i >= 0; i--) {
+    const p = points[i];
+    while (lowerHull.length >= 2) {
+      const q = lowerHull[lowerHull.length - 1];
+      const r = lowerHull[lowerHull.length - 2];
+      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x)) lowerHull.pop();
+      else break;
+    }
+    lowerHull.push(p);
+  }
+  lowerHull.pop();
+  if (upperHull.length === 1 && lowerHull.length === 1 && upperHull[0].x === lowerHull[0].x && upperHull[0].y === lowerHull[0].y) {
+    return upperHull;
+  } else {
+    return upperHull.concat(lowerHull);
+  }
+}
+var Provider = TooltipProvider;
+var Root3 = Tooltip;
+var Trigger = TooltipTrigger;
+var Portal = TooltipPortal;
+var Content2 = TooltipContent;
+var Arrow2 = TooltipArrow;
+export {
+  Arrow2 as Arrow,
+  Content2 as Content,
+  Portal,
+  Provider,
+  Root3 as Root,
+  Tooltip,
+  TooltipArrow,
+  TooltipContent,
+  TooltipPortal,
+  TooltipProvider,
+  TooltipTrigger,
+  Trigger
+};

package/dist/index64.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"}),exports.composeEventHandlers=function(e,t,{checkForDefaultPrevented:n=!0}={}){return function(r){if(null==e||e(r),!1===n||!r.defaultPrevented)return null==t?void 0:t(r)}};

package/dist/index64.js

@@ -0,0 +1,11 @@
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler == null ? void 0 : originalEventHandler(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      return ourEventHandler == null ? void 0 : ourEventHandler(event);
+    }
+  };
+}
+export {
+  composeEventHandlers
+};

package/dist/index65.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function e(e){const t=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e)for(const n in e)if("default"!==n){const o=Object.getOwnPropertyDescriptor(e,n);Object.defineProperty(t,n,o.get?o:{enumerable:!0,get:()=>e[n]})}return t.default=e,Object.freeze(t)}const t=e(require("react"));function n(e,t){if("function"==typeof e)return e(t);null!=e&&(e.current=t)}function o(...e){return t=>{let o=!1;const r=e.map(e=>{const r=n(e,t);return o||"function"!=typeof r||(o=!0),r});if(o)return()=>{for(let t=0;t<r.length;t++){const o=r[t];"function"==typeof o?o():n(e[t],null)}}}}exports.composeRefs=o,exports.useComposedRefs=function(...e){return t.useCallback(o(...e),e)};