@dreamcommerce/aurora 3.1.46-1 → 3.1.46-3

package/build/esm/external/@radix-ui/react-toast/dist/index.mjs.js

@@ -0,0 +1,722 @@
+import { useState, useRef, useCallback, forwardRef, useEffect, useMemo } from 'react';
+import { slicedToArray as _slicedToArray, objectWithoutProperties as _objectWithoutProperties, toConsumableArray as _toConsumableArray, objectSpread2 as _objectSpread2 } from '../../../../_virtual/_rollupPluginBabelHelpers.js';
+import { createPortal } from 'react-dom';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { createContextScope } from '../../react-context/dist/index.mjs.js';
+import { useCallbackRef } from '../../react-use-callback-ref/dist/index.mjs.js';
+import { useControllableState } from '../../react-use-controllable-state/dist/index.mjs.js';
+import { useLayoutEffect as useLayoutEffect2 } from '../../react-use-layout-effect/dist/index.mjs.js';
+import { useComposedRefs } from '../../react-compose-refs/dist/index.mjs.js';
+import { Presence } from '../../react-presence/dist/index.mjs.js';
+import { composeEventHandlers } from '../external/@radix-ui/primitive/dist/index.mjs.js';
+import { createCollection } from '../external/@radix-ui/react-collection/dist/index.mjs.js';
+import { Primitive, dispatchDiscreteCustomEvent } from '../external/@radix-ui/react-primitive/dist/index.mjs.js';
+import { Branch, Root } from '../external/@radix-ui/react-dismissable-layer/dist/index.mjs.js';
+import { Portal } from '../external/@radix-ui/react-portal/dist/index.mjs.js';
+import { VisuallyHidden } from '../external/@radix-ui/react-visually-hidden/dist/index.mjs.js';
+
+var _excluded = ["__scopeToast", "hotkey", "label"],
+  _excluded2 = ["__scopeToast", "onFocusFromOutsideViewport"],
+  _excluded3 = ["forceMount", "open", "defaultOpen", "onOpenChange"],
+  _excluded4 = ["__scopeToast", "type", "duration", "open", "onClose", "onEscapeKeyDown", "onPause", "onResume", "onSwipeStart", "onSwipeMove", "onSwipeCancel", "onSwipeEnd"],
+  _excluded5 = ["__scopeToast", "children"],
+  _excluded6 = ["__scopeToast"],
+  _excluded7 = ["__scopeToast"],
+  _excluded8 = ["altText"],
+  _excluded9 = ["__scopeToast"],
+  _excluded10 = ["__scopeToast", "altText"];
+var PROVIDER_NAME = "ToastProvider";
+var _createCollection = createCollection("Toast"),
+  _createCollection2 = _slicedToArray(_createCollection, 3),
+  Collection = _createCollection2[0],
+  useCollection = _createCollection2[1],
+  createCollectionScope = _createCollection2[2];
+var _createContextScope = createContextScope("Toast", [createCollectionScope]),
+  _createContextScope2 = _slicedToArray(_createContextScope, 2),
+  createToastContext = _createContextScope2[0],
+  createToastScope = _createContextScope2[1];
+var _createToastContext = createToastContext(PROVIDER_NAME),
+  _createToastContext2 = _slicedToArray(_createToastContext, 2),
+  ToastProviderProvider = _createToastContext2[0],
+  useToastProviderContext = _createToastContext2[1];
+var ToastProvider = function ToastProvider(props) {
+  var __scopeToast = props.__scopeToast,
+    _props$label = props.label,
+    label = _props$label === void 0 ? "Notification" : _props$label,
+    _props$duration = props.duration,
+    duration = _props$duration === void 0 ? 5e3 : _props$duration,
+    _props$swipeDirection = props.swipeDirection,
+    swipeDirection = _props$swipeDirection === void 0 ? "right" : _props$swipeDirection,
+    _props$swipeThreshold = props.swipeThreshold,
+    swipeThreshold = _props$swipeThreshold === void 0 ? 50 : _props$swipeThreshold,
+    children = props.children;
+  var _React$useState = useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    viewport = _React$useState2[0],
+    setViewport = _React$useState2[1];
+  var _React$useState3 = useState(0),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    toastCount = _React$useState4[0],
+    setToastCount = _React$useState4[1];
+  var isFocusedToastEscapeKeyDownRef = useRef(false);
+  var isClosePausedRef = useRef(false);
+  if (!label.trim()) {
+    console.error("Invalid prop `label` supplied to `".concat(PROVIDER_NAME, "`. Expected non-empty `string`."));
+  }
+  return /* @__PURE__ */jsx(Collection.Provider, {
+    scope: __scopeToast,
+    children: /* @__PURE__ */jsx(ToastProviderProvider, {
+      scope: __scopeToast,
+      label: label,
+      duration: duration,
+      swipeDirection: swipeDirection,
+      swipeThreshold: swipeThreshold,
+      toastCount: toastCount,
+      viewport: viewport,
+      onViewportChange: setViewport,
+      onToastAdd: useCallback(function () {
+        return setToastCount(function (prevCount) {
+          return prevCount + 1;
+        });
+      }, []),
+      onToastRemove: useCallback(function () {
+        return setToastCount(function (prevCount) {
+          return prevCount - 1;
+        });
+      }, []),
+      isFocusedToastEscapeKeyDownRef: isFocusedToastEscapeKeyDownRef,
+      isClosePausedRef: isClosePausedRef,
+      children: children
+    })
+  });
+};
+ToastProvider.displayName = PROVIDER_NAME;
+var VIEWPORT_NAME = "ToastViewport";
+var VIEWPORT_DEFAULT_HOTKEY = ["F8"];
+var VIEWPORT_PAUSE = "toast.viewportPause";
+var VIEWPORT_RESUME = "toast.viewportResume";
+var ToastViewport = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeToast = props.__scopeToast,
+    _props$hotkey = props.hotkey,
+    hotkey = _props$hotkey === void 0 ? VIEWPORT_DEFAULT_HOTKEY : _props$hotkey,
+    _props$label2 = props.label,
+    label = _props$label2 === void 0 ? "Notifications ({hotkey})" : _props$label2,
+    viewportProps = _objectWithoutProperties(props, _excluded);
+  var context = useToastProviderContext(VIEWPORT_NAME, __scopeToast);
+  var getItems = useCollection(__scopeToast);
+  var wrapperRef = useRef(null);
+  var headFocusProxyRef = useRef(null);
+  var tailFocusProxyRef = useRef(null);
+  var ref = useRef(null);
+  var composedRefs = useComposedRefs(forwardedRef, ref, context.onViewportChange);
+  var hotkeyLabel = hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, "");
+  var hasToasts = context.toastCount > 0;
+  useEffect(function () {
+    var handleKeyDown = function handleKeyDown(event) {
+      var _ref$current;
+      var isHotkeyPressed = hotkey.length !== 0 && hotkey.every(function (key) {
+        return event[key] || event.code === key;
+      });
+      if (isHotkeyPressed) (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.focus();
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return function () {
+      return document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [hotkey]);
+  useEffect(function () {
+    var wrapper = wrapperRef.current;
+    var viewport = ref.current;
+    if (hasToasts && wrapper && viewport) {
+      var handlePause = function handlePause() {
+        if (!context.isClosePausedRef.current) {
+          var pauseEvent = new CustomEvent(VIEWPORT_PAUSE);
+          viewport.dispatchEvent(pauseEvent);
+          context.isClosePausedRef.current = true;
+        }
+      };
+      var handleResume = function handleResume() {
+        if (context.isClosePausedRef.current) {
+          var resumeEvent = new CustomEvent(VIEWPORT_RESUME);
+          viewport.dispatchEvent(resumeEvent);
+          context.isClosePausedRef.current = false;
+        }
+      };
+      var handleFocusOutResume = function handleFocusOutResume(event) {
+        var isFocusMovingOutside = !wrapper.contains(event.relatedTarget);
+        if (isFocusMovingOutside) handleResume();
+      };
+      var handlePointerLeaveResume = function handlePointerLeaveResume() {
+        var isFocusInside = wrapper.contains(document.activeElement);
+        if (!isFocusInside) handleResume();
+      };
+      wrapper.addEventListener("focusin", handlePause);
+      wrapper.addEventListener("focusout", handleFocusOutResume);
+      wrapper.addEventListener("pointermove", handlePause);
+      wrapper.addEventListener("pointerleave", handlePointerLeaveResume);
+      window.addEventListener("blur", handlePause);
+      window.addEventListener("focus", handleResume);
+      return function () {
+        wrapper.removeEventListener("focusin", handlePause);
+        wrapper.removeEventListener("focusout", handleFocusOutResume);
+        wrapper.removeEventListener("pointermove", handlePause);
+        wrapper.removeEventListener("pointerleave", handlePointerLeaveResume);
+        window.removeEventListener("blur", handlePause);
+        window.removeEventListener("focus", handleResume);
+      };
+    }
+  }, [hasToasts, context.isClosePausedRef]);
+  var getSortedTabbableCandidates = useCallback(function (_ref) {
+    var tabbingDirection = _ref.tabbingDirection;
+    var toastItems = getItems();
+    var tabbableCandidates = toastItems.map(function (toastItem) {
+      var toastNode = toastItem.ref.current;
+      var toastTabbableCandidates = [toastNode].concat(_toConsumableArray(getTabbableCandidates(toastNode)));
+      return tabbingDirection === "forwards" ? toastTabbableCandidates : toastTabbableCandidates.reverse();
+    });
+    return (tabbingDirection === "forwards" ? tabbableCandidates.reverse() : tabbableCandidates).flat();
+  }, [getItems]);
+  useEffect(function () {
+    var viewport = ref.current;
+    if (viewport) {
+      var handleKeyDown = function handleKeyDown(event) {
+        var isMetaKey = event.altKey || event.ctrlKey || event.metaKey;
+        var isTabKey = event.key === "Tab" && !isMetaKey;
+        if (isTabKey) {
+          var focusedElement = document.activeElement;
+          var isTabbingBackwards = event.shiftKey;
+          var targetIsViewport = event.target === viewport;
+          if (targetIsViewport && isTabbingBackwards) {
+            var _headFocusProxyRef$cu;
+            (_headFocusProxyRef$cu = headFocusProxyRef.current) === null || _headFocusProxyRef$cu === void 0 ? void 0 : _headFocusProxyRef$cu.focus();
+            return;
+          }
+          var tabbingDirection = isTabbingBackwards ? "backwards" : "forwards";
+          var sortedCandidates = getSortedTabbableCandidates({
+            tabbingDirection: tabbingDirection
+          });
+          var index = sortedCandidates.findIndex(function (candidate) {
+            return candidate === focusedElement;
+          });
+          if (focusFirst(sortedCandidates.slice(index + 1))) {
+            event.preventDefault();
+          } else {
+            var _headFocusProxyRef$cu2, _tailFocusProxyRef$cu;
+            isTabbingBackwards ? (_headFocusProxyRef$cu2 = headFocusProxyRef.current) === null || _headFocusProxyRef$cu2 === void 0 ? void 0 : _headFocusProxyRef$cu2.focus() : (_tailFocusProxyRef$cu = tailFocusProxyRef.current) === null || _tailFocusProxyRef$cu === void 0 ? void 0 : _tailFocusProxyRef$cu.focus();
+          }
+        }
+      };
+      viewport.addEventListener("keydown", handleKeyDown);
+      return function () {
+        return viewport.removeEventListener("keydown", handleKeyDown);
+      };
+    }
+  }, [getItems, getSortedTabbableCandidates]);
+  return /* @__PURE__ */jsxs(Branch, {
+    ref: wrapperRef,
+    role: "region",
+    "aria-label": label.replace("{hotkey}", hotkeyLabel),
+    tabIndex: -1,
+    style: {
+      pointerEvents: hasToasts ? void 0 : "none"
+    },
+    children: [hasToasts && /* @__PURE__ */jsx(FocusProxy, {
+      ref: headFocusProxyRef,
+      onFocusFromOutsideViewport: function onFocusFromOutsideViewport() {
+        var tabbableCandidates = getSortedTabbableCandidates({
+          tabbingDirection: "forwards"
+        });
+        focusFirst(tabbableCandidates);
+      }
+    }), /* @__PURE__ */jsx(Collection.Slot, {
+      scope: __scopeToast,
+      children: /* @__PURE__ */jsx(Primitive.ol, _objectSpread2(_objectSpread2({
+        tabIndex: -1
+      }, viewportProps), {}, {
+        ref: composedRefs
+      }))
+    }), hasToasts && /* @__PURE__ */jsx(FocusProxy, {
+      ref: tailFocusProxyRef,
+      onFocusFromOutsideViewport: function onFocusFromOutsideViewport() {
+        var tabbableCandidates = getSortedTabbableCandidates({
+          tabbingDirection: "backwards"
+        });
+        focusFirst(tabbableCandidates);
+      }
+    })]
+  });
+});
+ToastViewport.displayName = VIEWPORT_NAME;
+var FOCUS_PROXY_NAME = "ToastFocusProxy";
+var FocusProxy = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeToast = props.__scopeToast,
+    onFocusFromOutsideViewport = props.onFocusFromOutsideViewport,
+    proxyProps = _objectWithoutProperties(props, _excluded2);
+  var context = useToastProviderContext(FOCUS_PROXY_NAME, __scopeToast);
+  return /* @__PURE__ */jsx(VisuallyHidden, _objectSpread2(_objectSpread2({
+    "aria-hidden": true,
+    tabIndex: 0
+  }, proxyProps), {}, {
+    ref: forwardedRef,
+    style: {
+      position: "fixed"
+    },
+    onFocus: function onFocus(event) {
+      var _context$viewport;
+      var prevFocusedElement = event.relatedTarget;
+      var isFocusFromOutsideViewport = !((_context$viewport = context.viewport) !== null && _context$viewport !== void 0 && _context$viewport.contains(prevFocusedElement));
+      if (isFocusFromOutsideViewport) onFocusFromOutsideViewport();
+    }
+  }));
+});
+FocusProxy.displayName = FOCUS_PROXY_NAME;
+var TOAST_NAME = "Toast";
+var TOAST_SWIPE_START = "toast.swipeStart";
+var TOAST_SWIPE_MOVE = "toast.swipeMove";
+var TOAST_SWIPE_CANCEL = "toast.swipeCancel";
+var TOAST_SWIPE_END = "toast.swipeEnd";
+var Toast = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var forceMount = props.forceMount,
+    openProp = props.open,
+    defaultOpen = props.defaultOpen,
+    onOpenChange = props.onOpenChange,
+    toastProps = _objectWithoutProperties(props, _excluded3);
+  var _useControllableState = useControllableState({
+      prop: openProp,
+      defaultProp: defaultOpen,
+      onChange: onOpenChange
+    }),
+    _useControllableState2 = _slicedToArray(_useControllableState, 2),
+    _useControllableState3 = _useControllableState2[0],
+    open = _useControllableState3 === void 0 ? true : _useControllableState3,
+    setOpen = _useControllableState2[1];
+  return /* @__PURE__ */jsx(Presence, {
+    present: forceMount || open,
+    children: /* @__PURE__ */jsx(ToastImpl, _objectSpread2(_objectSpread2({
+      open: open
+    }, toastProps), {}, {
+      ref: forwardedRef,
+      onClose: function onClose() {
+        return setOpen(false);
+      },
+      onPause: useCallbackRef(props.onPause),
+      onResume: useCallbackRef(props.onResume),
+      onSwipeStart: composeEventHandlers(props.onSwipeStart, function (event) {
+        event.currentTarget.setAttribute("data-swipe", "start");
+      }),
+      onSwipeMove: composeEventHandlers(props.onSwipeMove, function (event) {
+        var _event$detail$delta = event.detail.delta,
+          x = _event$detail$delta.x,
+          y = _event$detail$delta.y;
+        event.currentTarget.setAttribute("data-swipe", "move");
+        event.currentTarget.style.setProperty("--radix-toast-swipe-move-x", "".concat(x, "px"));
+        event.currentTarget.style.setProperty("--radix-toast-swipe-move-y", "".concat(y, "px"));
+      }),
+      onSwipeCancel: composeEventHandlers(props.onSwipeCancel, function (event) {
+        event.currentTarget.setAttribute("data-swipe", "cancel");
+        event.currentTarget.style.removeProperty("--radix-toast-swipe-move-x");
+        event.currentTarget.style.removeProperty("--radix-toast-swipe-move-y");
+        event.currentTarget.style.removeProperty("--radix-toast-swipe-end-x");
+        event.currentTarget.style.removeProperty("--radix-toast-swipe-end-y");
+      }),
+      onSwipeEnd: composeEventHandlers(props.onSwipeEnd, function (event) {
+        var _event$detail$delta2 = event.detail.delta,
+          x = _event$detail$delta2.x,
+          y = _event$detail$delta2.y;
+        event.currentTarget.setAttribute("data-swipe", "end");
+        event.currentTarget.style.removeProperty("--radix-toast-swipe-move-x");
+        event.currentTarget.style.removeProperty("--radix-toast-swipe-move-y");
+        event.currentTarget.style.setProperty("--radix-toast-swipe-end-x", "".concat(x, "px"));
+        event.currentTarget.style.setProperty("--radix-toast-swipe-end-y", "".concat(y, "px"));
+        setOpen(false);
+      })
+    }))
+  });
+});
+Toast.displayName = TOAST_NAME;
+var _createToastContext3 = createToastContext(TOAST_NAME, {
+    onClose: function onClose() {}
+  }),
+  _createToastContext4 = _slicedToArray(_createToastContext3, 2),
+  ToastInteractiveProvider = _createToastContext4[0],
+  useToastInteractiveContext = _createToastContext4[1];
+var ToastImpl = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeToast = props.__scopeToast,
+    _props$type = props.type,
+    type = _props$type === void 0 ? "foreground" : _props$type,
+    durationProp = props.duration,
+    open = props.open,
+    onClose = props.onClose,
+    onEscapeKeyDown = props.onEscapeKeyDown,
+    onPause = props.onPause,
+    onResume = props.onResume,
+    onSwipeStart = props.onSwipeStart,
+    onSwipeMove = props.onSwipeMove,
+    onSwipeCancel = props.onSwipeCancel,
+    onSwipeEnd = props.onSwipeEnd,
+    toastProps = _objectWithoutProperties(props, _excluded4);
+  var context = useToastProviderContext(TOAST_NAME, __scopeToast);
+  var _React$useState5 = useState(null),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    node = _React$useState6[0],
+    setNode = _React$useState6[1];
+  var composedRefs = useComposedRefs(forwardedRef, function (node2) {
+    return setNode(node2);
+  });
+  var pointerStartRef = useRef(null);
+  var swipeDeltaRef = useRef(null);
+  var duration = durationProp || context.duration;
+  var closeTimerStartTimeRef = useRef(0);
+  var closeTimerRemainingTimeRef = useRef(duration);
+  var closeTimerRef = useRef(0);
+  var onToastAdd = context.onToastAdd,
+    onToastRemove = context.onToastRemove;
+  var handleClose = useCallbackRef(function () {
+    var _context$viewport2;
+    var isFocusInToast = node === null || node === void 0 ? void 0 : node.contains(document.activeElement);
+    if (isFocusInToast) (_context$viewport2 = context.viewport) === null || _context$viewport2 === void 0 ? void 0 : _context$viewport2.focus();
+    onClose();
+  });
+  var startTimer = useCallback(function (duration2) {
+    if (!duration2 || duration2 === Infinity) return;
+    window.clearTimeout(closeTimerRef.current);
+    closeTimerStartTimeRef.current = (/* @__PURE__ */new Date()).getTime();
+    closeTimerRef.current = window.setTimeout(handleClose, duration2);
+  }, [handleClose]);
+  useEffect(function () {
+    var viewport = context.viewport;
+    if (viewport) {
+      var handleResume = function handleResume() {
+        startTimer(closeTimerRemainingTimeRef.current);
+        onResume === null || onResume === void 0 ? void 0 : onResume();
+      };
+      var handlePause = function handlePause() {
+        var elapsedTime = (/* @__PURE__ */new Date()).getTime() - closeTimerStartTimeRef.current;
+        closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime;
+        window.clearTimeout(closeTimerRef.current);
+        onPause === null || onPause === void 0 ? void 0 : onPause();
+      };
+      viewport.addEventListener(VIEWPORT_PAUSE, handlePause);
+      viewport.addEventListener(VIEWPORT_RESUME, handleResume);
+      return function () {
+        viewport.removeEventListener(VIEWPORT_PAUSE, handlePause);
+        viewport.removeEventListener(VIEWPORT_RESUME, handleResume);
+      };
+    }
+  }, [context.viewport, duration, onPause, onResume, startTimer]);
+  useEffect(function () {
+    if (open && !context.isClosePausedRef.current) startTimer(duration);
+  }, [open, duration, context.isClosePausedRef, startTimer]);
+  useEffect(function () {
+    onToastAdd();
+    return function () {
+      return onToastRemove();
+    };
+  }, [onToastAdd, onToastRemove]);
+  var announceTextContent = useMemo(function () {
+    return node ? getAnnounceTextContent(node) : null;
+  }, [node]);
+  if (!context.viewport) return null;
+  return /* @__PURE__ */jsxs(Fragment, {
+    children: [announceTextContent && /* @__PURE__ */jsx(ToastAnnounce, {
+      __scopeToast: __scopeToast,
+      role: "status",
+      "aria-live": type === "foreground" ? "assertive" : "polite",
+      "aria-atomic": true,
+      children: announceTextContent
+    }), /* @__PURE__ */jsx(ToastInteractiveProvider, {
+      scope: __scopeToast,
+      onClose: handleClose,
+      children: /*#__PURE__*/createPortal(/* @__PURE__ */jsx(Collection.ItemSlot, {
+        scope: __scopeToast,
+        children: /* @__PURE__ */jsx(Root, {
+          asChild: true,
+          onEscapeKeyDown: composeEventHandlers(onEscapeKeyDown, function () {
+            if (!context.isFocusedToastEscapeKeyDownRef.current) handleClose();
+            context.isFocusedToastEscapeKeyDownRef.current = false;
+          }),
+          children: /* @__PURE__ */jsx(Primitive.li, _objectSpread2(_objectSpread2({
+            role: "status",
+            "aria-live": "off",
+            "aria-atomic": true,
+            tabIndex: 0,
+            "data-state": open ? "open" : "closed",
+            "data-swipe-direction": context.swipeDirection
+          }, toastProps), {}, {
+            ref: composedRefs,
+            style: _objectSpread2({
+              userSelect: "none",
+              touchAction: "none"
+            }, props.style),
+            onKeyDown: composeEventHandlers(props.onKeyDown, function (event) {
+              if (event.key !== "Escape") return;
+              onEscapeKeyDown === null || onEscapeKeyDown === void 0 ? void 0 : onEscapeKeyDown(event.nativeEvent);
+              if (!event.nativeEvent.defaultPrevented) {
+                context.isFocusedToastEscapeKeyDownRef.current = true;
+                handleClose();
+              }
+            }),
+            onPointerDown: composeEventHandlers(props.onPointerDown, function (event) {
+              if (event.button !== 0) return;
+              pointerStartRef.current = {
+                x: event.clientX,
+                y: event.clientY
+              };
+            }),
+            onPointerMove: composeEventHandlers(props.onPointerMove, function (event) {
+              if (!pointerStartRef.current) return;
+              var x = event.clientX - pointerStartRef.current.x;
+              var y = event.clientY - pointerStartRef.current.y;
+              var hasSwipeMoveStarted = Boolean(swipeDeltaRef.current);
+              var isHorizontalSwipe = ["left", "right"].includes(context.swipeDirection);
+              var clamp = ["left", "up"].includes(context.swipeDirection) ? Math.min : Math.max;
+              var clampedX = isHorizontalSwipe ? clamp(0, x) : 0;
+              var clampedY = !isHorizontalSwipe ? clamp(0, y) : 0;
+              var moveStartBuffer = event.pointerType === "touch" ? 10 : 2;
+              var delta = {
+                x: clampedX,
+                y: clampedY
+              };
+              var eventDetail = {
+                originalEvent: event,
+                delta: delta
+              };
+              if (hasSwipeMoveStarted) {
+                swipeDeltaRef.current = delta;
+                handleAndDispatchCustomEvent(TOAST_SWIPE_MOVE, onSwipeMove, eventDetail, {
+                  discrete: false
+                });
+              } else if (isDeltaInDirection(delta, context.swipeDirection, moveStartBuffer)) {
+                swipeDeltaRef.current = delta;
+                handleAndDispatchCustomEvent(TOAST_SWIPE_START, onSwipeStart, eventDetail, {
+                  discrete: false
+                });
+                event.target.setPointerCapture(event.pointerId);
+              } else if (Math.abs(x) > moveStartBuffer || Math.abs(y) > moveStartBuffer) {
+                pointerStartRef.current = null;
+              }
+            }),
+            onPointerUp: composeEventHandlers(props.onPointerUp, function (event) {
+              var delta = swipeDeltaRef.current;
+              var target = event.target;
+              if (target.hasPointerCapture(event.pointerId)) {
+                target.releasePointerCapture(event.pointerId);
+              }
+              swipeDeltaRef.current = null;
+              pointerStartRef.current = null;
+              if (delta) {
+                var toast = event.currentTarget;
+                var eventDetail = {
+                  originalEvent: event,
+                  delta: delta
+                };
+                if (isDeltaInDirection(delta, context.swipeDirection, context.swipeThreshold)) {
+                  handleAndDispatchCustomEvent(TOAST_SWIPE_END, onSwipeEnd, eventDetail, {
+                    discrete: true
+                  });
+                } else {
+                  handleAndDispatchCustomEvent(TOAST_SWIPE_CANCEL, onSwipeCancel, eventDetail, {
+                    discrete: true
+                  });
+                }
+                toast.addEventListener("click", function (event2) {
+                  return event2.preventDefault();
+                }, {
+                  once: true
+                });
+              }
+            })
+          }))
+        })
+      }), context.viewport)
+    })]
+  });
+});
+var ToastAnnounce = function ToastAnnounce(props) {
+  var __scopeToast = props.__scopeToast,
+    children = props.children,
+    announceProps = _objectWithoutProperties(props, _excluded5);
+  var context = useToastProviderContext(TOAST_NAME, __scopeToast);
+  var _React$useState7 = useState(false),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    renderAnnounceText = _React$useState8[0],
+    setRenderAnnounceText = _React$useState8[1];
+  var _React$useState9 = useState(false),
+    _React$useState10 = _slicedToArray(_React$useState9, 2),
+    isAnnounced = _React$useState10[0],
+    setIsAnnounced = _React$useState10[1];
+  useNextFrame(function () {
+    return setRenderAnnounceText(true);
+  });
+  useEffect(function () {
+    var timer = window.setTimeout(function () {
+      return setIsAnnounced(true);
+    }, 1e3);
+    return function () {
+      return window.clearTimeout(timer);
+    };
+  }, []);
+  return isAnnounced ? null : /* @__PURE__ */jsx(Portal, {
+    asChild: true,
+    children: /* @__PURE__ */jsx(VisuallyHidden, _objectSpread2(_objectSpread2({}, announceProps), {}, {
+      children: renderAnnounceText && /* @__PURE__ */jsxs(Fragment, {
+        children: [context.label, " ", children]
+      })
+    }))
+  });
+};
+var TITLE_NAME = "ToastTitle";
+var ToastTitle = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeToast = props.__scopeToast,
+    titleProps = _objectWithoutProperties(props, _excluded6);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({}, titleProps), {}, {
+    ref: forwardedRef
+  }));
+});
+ToastTitle.displayName = TITLE_NAME;
+var DESCRIPTION_NAME = "ToastDescription";
+var ToastDescription = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeToast = props.__scopeToast,
+    descriptionProps = _objectWithoutProperties(props, _excluded7);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({}, descriptionProps), {}, {
+    ref: forwardedRef
+  }));
+});
+ToastDescription.displayName = DESCRIPTION_NAME;
+var ACTION_NAME = "ToastAction";
+var ToastAction = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var altText = props.altText,
+    actionProps = _objectWithoutProperties(props, _excluded8);
+  if (!altText.trim()) {
+    console.error("Invalid prop `altText` supplied to `".concat(ACTION_NAME, "`. Expected non-empty `string`."));
+    return null;
+  }
+  return /* @__PURE__ */jsx(ToastAnnounceExclude, {
+    altText: altText,
+    asChild: true,
+    children: /* @__PURE__ */jsx(ToastClose, _objectSpread2(_objectSpread2({}, actionProps), {}, {
+      ref: forwardedRef
+    }))
+  });
+});
+ToastAction.displayName = ACTION_NAME;
+var CLOSE_NAME = "ToastClose";
+var ToastClose = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeToast = props.__scopeToast,
+    closeProps = _objectWithoutProperties(props, _excluded9);
+  var interactiveContext = useToastInteractiveContext(CLOSE_NAME, __scopeToast);
+  return /* @__PURE__ */jsx(ToastAnnounceExclude, {
+    asChild: true,
+    children: /* @__PURE__ */jsx(Primitive.button, _objectSpread2(_objectSpread2({
+      type: "button"
+    }, closeProps), {}, {
+      ref: forwardedRef,
+      onClick: composeEventHandlers(props.onClick, interactiveContext.onClose)
+    }))
+  });
+});
+ToastClose.displayName = CLOSE_NAME;
+var ToastAnnounceExclude = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeToast = props.__scopeToast,
+    altText = props.altText,
+    announceExcludeProps = _objectWithoutProperties(props, _excluded10);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+    "data-radix-toast-announce-exclude": "",
+    "data-radix-toast-announce-alt": altText || void 0
+  }, announceExcludeProps), {}, {
+    ref: forwardedRef
+  }));
+});
+function getAnnounceTextContent(container) {
+  var textContent = [];
+  var childNodes = Array.from(container.childNodes);
+  childNodes.forEach(function (node) {
+    if (node.nodeType === node.TEXT_NODE && node.textContent) textContent.push(node.textContent);
+    if (isHTMLElement(node)) {
+      var isHidden = node.ariaHidden || node.hidden || node.style.display === "none";
+      var isExcluded = node.dataset.radixToastAnnounceExclude === "";
+      if (!isHidden) {
+        if (isExcluded) {
+          var altText = node.dataset.radixToastAnnounceAlt;
+          if (altText) textContent.push(altText);
+        } else {
+          textContent.push.apply(textContent, _toConsumableArray(getAnnounceTextContent(node)));
+        }
+      }
+    }
+  });
+  return textContent;
+}
+function handleAndDispatchCustomEvent(name, handler, detail, _ref2) {
+  var discrete = _ref2.discrete;
+  var currentTarget = detail.originalEvent.currentTarget;
+  var event = new CustomEvent(name, {
+    bubbles: true,
+    cancelable: true,
+    detail: detail
+  });
+  if (handler) currentTarget.addEventListener(name, handler, {
+    once: true
+  });
+  if (discrete) {
+    dispatchDiscreteCustomEvent(currentTarget, event);
+  } else {
+    currentTarget.dispatchEvent(event);
+  }
+}
+var isDeltaInDirection = function isDeltaInDirection(delta, direction) {
+  var threshold = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var deltaX = Math.abs(delta.x);
+  var deltaY = Math.abs(delta.y);
+  var isDeltaX = deltaX > deltaY;
+  if (direction === "left" || direction === "right") {
+    return isDeltaX && deltaX > threshold;
+  } else {
+    return !isDeltaX && deltaY > threshold;
+  }
+};
+function useNextFrame() {
+  var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function () {};
+  var fn = useCallbackRef(callback);
+  useLayoutEffect2(function () {
+    var raf1 = 0;
+    var raf2 = 0;
+    raf1 = window.requestAnimationFrame(function () {
+      return raf2 = window.requestAnimationFrame(fn);
+    });
+    return function () {
+      window.cancelAnimationFrame(raf1);
+      window.cancelAnimationFrame(raf2);
+    };
+  }, [fn]);
+}
+function isHTMLElement(node) {
+  return node.nodeType === node.ELEMENT_NODE;
+}
+function getTabbableCandidates(container) {
+  var nodes = [];
+  var walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: function acceptNode(node) {
+      var isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
+      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
+      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  while (walker.nextNode()) nodes.push(walker.currentNode);
+  return nodes;
+}
+function focusFirst(candidates) {
+  var previouslyFocusedElement = document.activeElement;
+  return candidates.some(function (candidate) {
+    if (candidate === previouslyFocusedElement) return true;
+    candidate.focus();
+    return document.activeElement !== previouslyFocusedElement;
+  });
+}
+var Provider = ToastProvider;
+var Viewport = ToastViewport;
+var Root2 = Toast;
+var Close = ToastClose;
+
+export { Close, Provider, Root2 as Root, Toast, ToastAction, ToastClose, ToastDescription, ToastProvider, ToastTitle, ToastViewport, Viewport, createToastScope };
+//# sourceMappingURL=index.mjs.js.map