@sparrowengg/integrations-templates-frontend 8.0.4 → 8.0.5

package/dist/cjs/node_modules/@sparrowengg/twigs-react/dist/es/node_modules/@radix-ui/react-toast/dist/index.js

@@ -0,0 +1,731 @@
+'use strict';
+
+var React = require('react');
+var ReactDOM = require('react-dom');
+var index$6 = require('../../primitive/dist/index.js');
+var index$2 = require('../../react-compose-refs/dist/index.js');
+var index$1 = require('../../react-collection/dist/index.js');
+var index$8 = require('../../react-context/dist/index.js');
+var index$3 = require('../../react-dismissable-layer/dist/index.js');
+var index$a = require('../../react-portal/dist/index.js');
+var index$5 = require('../../react-presence/dist/index.js');
+var index = require('../../react-primitive/dist/index.js');
+var index$7 = require('../../react-use-callback-ref/dist/index.js');
+var index$4 = require('../../react-use-controllable-state/dist/index.js');
+var index$b = require('../../react-use-layout-effect/dist/index.js');
+var index$9 = require('../../react-visually-hidden/dist/index.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+var ReactDOM__namespace = /*#__PURE__*/_interopNamespaceDefault(ReactDOM);
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var PROVIDER_NAME = "ToastProvider";
+var [Collection, useCollection, createCollectionScope] = index$1.createCollection("Toast");
+var [createToastContext] = index$8.createContextScope("Toast", [createCollectionScope]);
+var [ToastProviderProvider, useToastProviderContext] = createToastContext(PROVIDER_NAME);
+var ToastProvider = (props) => {
+  const {
+    __scopeToast,
+    label = "Notification",
+    duration = 5e3,
+    swipeDirection = "right",
+    swipeThreshold = 50,
+    children
+  } = props;
+  const [viewport, setViewport] = React__namespace.useState(null);
+  const [toastCount, setToastCount] = React__namespace.useState(0);
+  const isFocusedToastEscapeKeyDownRef = React__namespace.useRef(false);
+  const isClosePausedRef = React__namespace.useRef(false);
+  if (!label.trim()) {
+    console.error(
+      `Invalid prop \`label\` supplied to \`${PROVIDER_NAME}\`. Expected non-empty \`string\`.`
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(Collection.Provider, { scope: __scopeToast, children: /* @__PURE__ */ jsxRuntime.jsx(
+    ToastProviderProvider,
+    {
+      scope: __scopeToast,
+      label,
+      duration,
+      swipeDirection,
+      swipeThreshold,
+      toastCount,
+      viewport,
+      onViewportChange: setViewport,
+      onToastAdd: React__namespace.useCallback(() => setToastCount((prevCount) => prevCount + 1), []),
+      onToastRemove: React__namespace.useCallback(() => setToastCount((prevCount) => prevCount - 1), []),
+      isFocusedToastEscapeKeyDownRef,
+      isClosePausedRef,
+      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 = React__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const _a = props, {
+      __scopeToast,
+      hotkey = VIEWPORT_DEFAULT_HOTKEY,
+      label = "Notifications ({hotkey})"
+    } = _a, viewportProps = __objRest(_a, [
+      "__scopeToast",
+      "hotkey",
+      "label"
+    ]);
+    const context = useToastProviderContext(VIEWPORT_NAME, __scopeToast);
+    const getItems = useCollection(__scopeToast);
+    const wrapperRef = React__namespace.useRef(null);
+    const headFocusProxyRef = React__namespace.useRef(null);
+    const tailFocusProxyRef = React__namespace.useRef(null);
+    const ref = React__namespace.useRef(null);
+    const composedRefs = index$2.useComposedRefs(forwardedRef, ref, context.onViewportChange);
+    const hotkeyLabel = hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, "");
+    const hasToasts = context.toastCount > 0;
+    React__namespace.useEffect(() => {
+      const handleKeyDown = (event) => {
+        var _a2;
+        const isHotkeyPressed = hotkey.length !== 0 && hotkey.every((key) => event[key] || event.code === key);
+        if (isHotkeyPressed)
+          (_a2 = ref.current) == null ? void 0 : _a2.focus();
+      };
+      document.addEventListener("keydown", handleKeyDown);
+      return () => document.removeEventListener("keydown", handleKeyDown);
+    }, [hotkey]);
+    React__namespace.useEffect(() => {
+      const wrapper = wrapperRef.current;
+      const viewport = ref.current;
+      if (hasToasts && wrapper && viewport) {
+        const handlePause = () => {
+          if (!context.isClosePausedRef.current) {
+            const pauseEvent = new CustomEvent(VIEWPORT_PAUSE);
+            viewport.dispatchEvent(pauseEvent);
+            context.isClosePausedRef.current = true;
+          }
+        };
+        const handleResume = () => {
+          if (context.isClosePausedRef.current) {
+            const resumeEvent = new CustomEvent(VIEWPORT_RESUME);
+            viewport.dispatchEvent(resumeEvent);
+            context.isClosePausedRef.current = false;
+          }
+        };
+        const handleFocusOutResume = (event) => {
+          const isFocusMovingOutside = !wrapper.contains(event.relatedTarget);
+          if (isFocusMovingOutside)
+            handleResume();
+        };
+        const handlePointerLeaveResume = () => {
+          const 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 () => {
+          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]);
+    const getSortedTabbableCandidates = React__namespace.useCallback(
+      ({ tabbingDirection }) => {
+        const toastItems = getItems();
+        const tabbableCandidates = toastItems.map((toastItem) => {
+          const toastNode = toastItem.ref.current;
+          const toastTabbableCandidates = [toastNode, ...getTabbableCandidates(toastNode)];
+          return tabbingDirection === "forwards" ? toastTabbableCandidates : toastTabbableCandidates.reverse();
+        });
+        return (tabbingDirection === "forwards" ? tabbableCandidates.reverse() : tabbableCandidates).flat();
+      },
+      [getItems]
+    );
+    React__namespace.useEffect(() => {
+      const viewport = ref.current;
+      if (viewport) {
+        const handleKeyDown = (event) => {
+          var _a2, _b, _c;
+          const isMetaKey = event.altKey || event.ctrlKey || event.metaKey;
+          const isTabKey = event.key === "Tab" && !isMetaKey;
+          if (isTabKey) {
+            const focusedElement = document.activeElement;
+            const isTabbingBackwards = event.shiftKey;
+            const targetIsViewport = event.target === viewport;
+            if (targetIsViewport && isTabbingBackwards) {
+              (_a2 = headFocusProxyRef.current) == null ? void 0 : _a2.focus();
+              return;
+            }
+            const tabbingDirection = isTabbingBackwards ? "backwards" : "forwards";
+            const sortedCandidates = getSortedTabbableCandidates({ tabbingDirection });
+            const index = sortedCandidates.findIndex((candidate) => candidate === focusedElement);
+            if (focusFirst(sortedCandidates.slice(index + 1))) {
+              event.preventDefault();
+            } else {
+              isTabbingBackwards ? (_b = headFocusProxyRef.current) == null ? void 0 : _b.focus() : (_c = tailFocusProxyRef.current) == null ? void 0 : _c.focus();
+            }
+          }
+        };
+        viewport.addEventListener("keydown", handleKeyDown);
+        return () => viewport.removeEventListener("keydown", handleKeyDown);
+      }
+    }, [getItems, getSortedTabbableCandidates]);
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      index$3.Branch,
+      {
+        ref: wrapperRef,
+        role: "region",
+        "aria-label": label.replace("{hotkey}", hotkeyLabel),
+        tabIndex: -1,
+        style: { pointerEvents: hasToasts ? void 0 : "none" },
+        children: [
+          hasToasts && /* @__PURE__ */ jsxRuntime.jsx(
+            FocusProxy,
+            {
+              ref: headFocusProxyRef,
+              onFocusFromOutsideViewport: () => {
+                const tabbableCandidates = getSortedTabbableCandidates({
+                  tabbingDirection: "forwards"
+                });
+                focusFirst(tabbableCandidates);
+              }
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(Collection.Slot, { scope: __scopeToast, children: /* @__PURE__ */ jsxRuntime.jsx(index.Primitive.ol, __spreadProps(__spreadValues({ tabIndex: -1 }, viewportProps), { ref: composedRefs })) }),
+          hasToasts && /* @__PURE__ */ jsxRuntime.jsx(
+            FocusProxy,
+            {
+              ref: tailFocusProxyRef,
+              onFocusFromOutsideViewport: () => {
+                const tabbableCandidates = getSortedTabbableCandidates({
+                  tabbingDirection: "backwards"
+                });
+                focusFirst(tabbableCandidates);
+              }
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+ToastViewport.displayName = VIEWPORT_NAME;
+var FOCUS_PROXY_NAME = "ToastFocusProxy";
+var FocusProxy = React__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const _a = props, { __scopeToast, onFocusFromOutsideViewport } = _a, proxyProps = __objRest(_a, ["__scopeToast", "onFocusFromOutsideViewport"]);
+    const context = useToastProviderContext(FOCUS_PROXY_NAME, __scopeToast);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      index$9.VisuallyHidden,
+      __spreadProps(__spreadValues({
+        tabIndex: 0
+      }, proxyProps), {
+        ref: forwardedRef,
+        style: { position: "fixed" },
+        onFocus: (event) => {
+          var _a2;
+          const prevFocusedElement = event.relatedTarget;
+          const isFocusFromOutsideViewport = !((_a2 = context.viewport) == null ? void 0 : _a2.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 = React__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const _a = props, { forceMount, open: openProp, defaultOpen, onOpenChange } = _a, toastProps = __objRest(_a, ["forceMount", "open", "defaultOpen", "onOpenChange"]);
+    const [open, setOpen] = index$4.useControllableState({
+      prop: openProp,
+      defaultProp: defaultOpen != null ? defaultOpen : true,
+      onChange: onOpenChange,
+      caller: TOAST_NAME
+    });
+    return /* @__PURE__ */ jsxRuntime.jsx(index$5.Presence, { present: forceMount || open, children: /* @__PURE__ */ jsxRuntime.jsx(
+      ToastImpl,
+      __spreadProps(__spreadValues({
+        open
+      }, toastProps), {
+        ref: forwardedRef,
+        onClose: () => setOpen(false),
+        onPause: index$7.useCallbackRef(props.onPause),
+        onResume: index$7.useCallbackRef(props.onResume),
+        onSwipeStart: index$6.composeEventHandlers(props.onSwipeStart, (event) => {
+          event.currentTarget.setAttribute("data-swipe", "start");
+        }),
+        onSwipeMove: index$6.composeEventHandlers(props.onSwipeMove, (event) => {
+          const { x, y } = event.detail.delta;
+          event.currentTarget.setAttribute("data-swipe", "move");
+          event.currentTarget.style.setProperty("--radix-toast-swipe-move-x", `${x}px`);
+          event.currentTarget.style.setProperty("--radix-toast-swipe-move-y", `${y}px`);
+        }),
+        onSwipeCancel: index$6.composeEventHandlers(props.onSwipeCancel, (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: index$6.composeEventHandlers(props.onSwipeEnd, (event) => {
+          const { x, y } = event.detail.delta;
+          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", `${x}px`);
+          event.currentTarget.style.setProperty("--radix-toast-swipe-end-y", `${y}px`);
+          setOpen(false);
+        })
+      })
+    ) });
+  }
+);
+Toast.displayName = TOAST_NAME;
+var [ToastInteractiveProvider, useToastInteractiveContext] = createToastContext(TOAST_NAME, {
+  onClose() {
+  }
+});
+var ToastImpl = React__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const _a = props, {
+      __scopeToast,
+      type = "foreground",
+      duration: durationProp,
+      open,
+      onClose,
+      onEscapeKeyDown,
+      onPause,
+      onResume,
+      onSwipeStart,
+      onSwipeMove,
+      onSwipeCancel,
+      onSwipeEnd
+    } = _a, toastProps = __objRest(_a, [
+      "__scopeToast",
+      "type",
+      "duration",
+      "open",
+      "onClose",
+      "onEscapeKeyDown",
+      "onPause",
+      "onResume",
+      "onSwipeStart",
+      "onSwipeMove",
+      "onSwipeCancel",
+      "onSwipeEnd"
+    ]);
+    const context = useToastProviderContext(TOAST_NAME, __scopeToast);
+    const [node, setNode] = React__namespace.useState(null);
+    const composedRefs = index$2.useComposedRefs(forwardedRef, (node2) => setNode(node2));
+    const pointerStartRef = React__namespace.useRef(null);
+    const swipeDeltaRef = React__namespace.useRef(null);
+    const duration = durationProp || context.duration;
+    const closeTimerStartTimeRef = React__namespace.useRef(0);
+    const closeTimerRemainingTimeRef = React__namespace.useRef(duration);
+    const closeTimerRef = React__namespace.useRef(0);
+    const { onToastAdd, onToastRemove } = context;
+    const handleClose = index$7.useCallbackRef(() => {
+      var _a2;
+      const isFocusInToast = node == null ? void 0 : node.contains(document.activeElement);
+      if (isFocusInToast)
+        (_a2 = context.viewport) == null ? void 0 : _a2.focus();
+      onClose();
+    });
+    const startTimer = React__namespace.useCallback(
+      (duration2) => {
+        if (!duration2 || duration2 === Infinity)
+          return;
+        window.clearTimeout(closeTimerRef.current);
+        closeTimerStartTimeRef.current = (/* @__PURE__ */ new Date()).getTime();
+        closeTimerRef.current = window.setTimeout(handleClose, duration2);
+      },
+      [handleClose]
+    );
+    React__namespace.useEffect(() => {
+      const viewport = context.viewport;
+      if (viewport) {
+        const handleResume = () => {
+          startTimer(closeTimerRemainingTimeRef.current);
+          onResume == null ? void 0 : onResume();
+        };
+        const handlePause = () => {
+          const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - closeTimerStartTimeRef.current;
+          closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime;
+          window.clearTimeout(closeTimerRef.current);
+          onPause == null ? void 0 : onPause();
+        };
+        viewport.addEventListener(VIEWPORT_PAUSE, handlePause);
+        viewport.addEventListener(VIEWPORT_RESUME, handleResume);
+        return () => {
+          viewport.removeEventListener(VIEWPORT_PAUSE, handlePause);
+          viewport.removeEventListener(VIEWPORT_RESUME, handleResume);
+        };
+      }
+    }, [context.viewport, duration, onPause, onResume, startTimer]);
+    React__namespace.useEffect(() => {
+      if (open && !context.isClosePausedRef.current)
+        startTimer(duration);
+    }, [open, duration, context.isClosePausedRef, startTimer]);
+    React__namespace.useEffect(() => {
+      onToastAdd();
+      return () => onToastRemove();
+    }, [onToastAdd, onToastRemove]);
+    const announceTextContent = React__namespace.useMemo(() => {
+      return node ? getAnnounceTextContent(node) : null;
+    }, [node]);
+    if (!context.viewport)
+      return null;
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      announceTextContent && /* @__PURE__ */ jsxRuntime.jsx(
+        ToastAnnounce,
+        {
+          __scopeToast,
+          role: "status",
+          "aria-live": type === "foreground" ? "assertive" : "polite",
+          children: announceTextContent
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(ToastInteractiveProvider, { scope: __scopeToast, onClose: handleClose, children: ReactDOM__namespace.createPortal(
+        /* @__PURE__ */ jsxRuntime.jsx(Collection.ItemSlot, { scope: __scopeToast, children: /* @__PURE__ */ jsxRuntime.jsx(
+          index$3.Root,
+          {
+            asChild: true,
+            onEscapeKeyDown: index$6.composeEventHandlers(onEscapeKeyDown, () => {
+              if (!context.isFocusedToastEscapeKeyDownRef.current)
+                handleClose();
+              context.isFocusedToastEscapeKeyDownRef.current = false;
+            }),
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              index.Primitive.li,
+              __spreadProps(__spreadValues({
+                tabIndex: 0,
+                "data-state": open ? "open" : "closed",
+                "data-swipe-direction": context.swipeDirection
+              }, toastProps), {
+                ref: composedRefs,
+                style: __spreadValues({ userSelect: "none", touchAction: "none" }, props.style),
+                onKeyDown: index$6.composeEventHandlers(props.onKeyDown, (event) => {
+                  if (event.key !== "Escape")
+                    return;
+                  onEscapeKeyDown == null ? void 0 : onEscapeKeyDown(event.nativeEvent);
+                  if (!event.nativeEvent.defaultPrevented) {
+                    context.isFocusedToastEscapeKeyDownRef.current = true;
+                    handleClose();
+                  }
+                }),
+                onPointerDown: index$6.composeEventHandlers(props.onPointerDown, (event) => {
+                  if (event.button !== 0)
+                    return;
+                  pointerStartRef.current = { x: event.clientX, y: event.clientY };
+                }),
+                onPointerMove: index$6.composeEventHandlers(props.onPointerMove, (event) => {
+                  if (!pointerStartRef.current)
+                    return;
+                  const x = event.clientX - pointerStartRef.current.x;
+                  const y = event.clientY - pointerStartRef.current.y;
+                  const hasSwipeMoveStarted = Boolean(swipeDeltaRef.current);
+                  const isHorizontalSwipe = ["left", "right"].includes(context.swipeDirection);
+                  const clamp = ["left", "up"].includes(context.swipeDirection) ? Math.min : Math.max;
+                  const clampedX = isHorizontalSwipe ? clamp(0, x) : 0;
+                  const clampedY = !isHorizontalSwipe ? clamp(0, y) : 0;
+                  const moveStartBuffer = event.pointerType === "touch" ? 10 : 2;
+                  const delta = { x: clampedX, y: clampedY };
+                  const eventDetail = { originalEvent: event, 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: index$6.composeEventHandlers(props.onPointerUp, (event) => {
+                  const delta = swipeDeltaRef.current;
+                  const target = event.target;
+                  if (target.hasPointerCapture(event.pointerId)) {
+                    target.releasePointerCapture(event.pointerId);
+                  }
+                  swipeDeltaRef.current = null;
+                  pointerStartRef.current = null;
+                  if (delta) {
+                    const toast = event.currentTarget;
+                    const eventDetail = { originalEvent: event, 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", (event2) => event2.preventDefault(), {
+                      once: true
+                    });
+                  }
+                })
+              })
+            )
+          }
+        ) }),
+        context.viewport
+      ) })
+    ] });
+  }
+);
+var ToastAnnounce = (props) => {
+  const _a = props, { __scopeToast, children } = _a, announceProps = __objRest(_a, ["__scopeToast", "children"]);
+  const context = useToastProviderContext(TOAST_NAME, __scopeToast);
+  const [renderAnnounceText, setRenderAnnounceText] = React__namespace.useState(false);
+  const [isAnnounced, setIsAnnounced] = React__namespace.useState(false);
+  useNextFrame(() => setRenderAnnounceText(true));
+  React__namespace.useEffect(() => {
+    const timer = window.setTimeout(() => setIsAnnounced(true), 1e3);
+    return () => window.clearTimeout(timer);
+  }, []);
+  return isAnnounced ? null : /* @__PURE__ */ jsxRuntime.jsx(index$a.Portal, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(index$9.VisuallyHidden, __spreadProps(__spreadValues({}, announceProps), { children: renderAnnounceText && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    context.label,
+    " ",
+    children
+  ] }) })) });
+};
+var TITLE_NAME = "ToastTitle";
+var ToastTitle = React__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const _a = props, { __scopeToast } = _a, titleProps = __objRest(_a, ["__scopeToast"]);
+    return /* @__PURE__ */ jsxRuntime.jsx(index.Primitive.div, __spreadProps(__spreadValues({}, titleProps), { ref: forwardedRef }));
+  }
+);
+ToastTitle.displayName = TITLE_NAME;
+var DESCRIPTION_NAME = "ToastDescription";
+var ToastDescription = React__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const _a = props, { __scopeToast } = _a, descriptionProps = __objRest(_a, ["__scopeToast"]);
+    return /* @__PURE__ */ jsxRuntime.jsx(index.Primitive.div, __spreadProps(__spreadValues({}, descriptionProps), { ref: forwardedRef }));
+  }
+);
+ToastDescription.displayName = DESCRIPTION_NAME;
+var ACTION_NAME = "ToastAction";
+var ToastAction = React__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const _a = props, { altText } = _a, actionProps = __objRest(_a, ["altText"]);
+    if (!altText.trim()) {
+      console.error(
+        `Invalid prop \`altText\` supplied to \`${ACTION_NAME}\`. Expected non-empty \`string\`.`
+      );
+      return null;
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(ToastAnnounceExclude, { altText, asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(ToastClose, __spreadProps(__spreadValues({}, actionProps), { ref: forwardedRef })) });
+  }
+);
+ToastAction.displayName = ACTION_NAME;
+var CLOSE_NAME = "ToastClose";
+var ToastClose = React__namespace.forwardRef(
+  (props, forwardedRef) => {
+    const _a = props, { __scopeToast } = _a, closeProps = __objRest(_a, ["__scopeToast"]);
+    const interactiveContext = useToastInteractiveContext(CLOSE_NAME, __scopeToast);
+    return /* @__PURE__ */ jsxRuntime.jsx(ToastAnnounceExclude, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+      index.Primitive.button,
+      __spreadProps(__spreadValues({
+        type: "button"
+      }, closeProps), {
+        ref: forwardedRef,
+        onClick: index$6.composeEventHandlers(props.onClick, interactiveContext.onClose)
+      })
+    ) });
+  }
+);
+ToastClose.displayName = CLOSE_NAME;
+var ToastAnnounceExclude = React__namespace.forwardRef((props, forwardedRef) => {
+  const _a = props, { __scopeToast, altText } = _a, announceExcludeProps = __objRest(_a, ["__scopeToast", "altText"]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    index.Primitive.div,
+    __spreadProps(__spreadValues({
+      "data-radix-toast-announce-exclude": "",
+      "data-radix-toast-announce-alt": altText || void 0
+    }, announceExcludeProps), {
+      ref: forwardedRef
+    })
+  );
+});
+function getAnnounceTextContent(container) {
+  const textContent = [];
+  const childNodes = Array.from(container.childNodes);
+  childNodes.forEach((node) => {
+    if (node.nodeType === node.TEXT_NODE && node.textContent)
+      textContent.push(node.textContent);
+    if (isHTMLElement(node)) {
+      const isHidden = node.ariaHidden || node.hidden || node.style.display === "none";
+      const isExcluded = node.dataset.radixToastAnnounceExclude === "";
+      if (!isHidden) {
+        if (isExcluded) {
+          const altText = node.dataset.radixToastAnnounceAlt;
+          if (altText)
+            textContent.push(altText);
+        } else {
+          textContent.push(...getAnnounceTextContent(node));
+        }
+      }
+    }
+  });
+  return textContent;
+}
+function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
+  const currentTarget = detail.originalEvent.currentTarget;
+  const event = new CustomEvent(name, { bubbles: true, cancelable: true, detail });
+  if (handler)
+    currentTarget.addEventListener(name, handler, { once: true });
+  if (discrete) {
+    index.dispatchDiscreteCustomEvent(currentTarget, event);
+  } else {
+    currentTarget.dispatchEvent(event);
+  }
+}
+var isDeltaInDirection = (delta, direction, threshold = 0) => {
+  const deltaX = Math.abs(delta.x);
+  const deltaY = Math.abs(delta.y);
+  const isDeltaX = deltaX > deltaY;
+  if (direction === "left" || direction === "right") {
+    return isDeltaX && deltaX > threshold;
+  } else {
+    return !isDeltaX && deltaY > threshold;
+  }
+};
+function useNextFrame(callback = () => {
+}) {
+  const fn = index$7.useCallbackRef(callback);
+  index$b.useLayoutEffect(() => {
+    let raf1 = 0;
+    let raf2 = 0;
+    raf1 = window.requestAnimationFrame(() => raf2 = window.requestAnimationFrame(fn));
+    return () => {
+      window.cancelAnimationFrame(raf1);
+      window.cancelAnimationFrame(raf2);
+    };
+  }, [fn]);
+}
+function isHTMLElement(node) {
+  return node.nodeType === node.ELEMENT_NODE;
+}
+function getTabbableCandidates(container) {
+  const nodes = [];
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (node) => {
+      const 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) {
+  const previouslyFocusedElement = document.activeElement;
+  return candidates.some((candidate) => {
+    if (candidate === previouslyFocusedElement)
+      return true;
+    candidate.focus();
+    return document.activeElement !== previouslyFocusedElement;
+  });
+}
+var Provider = ToastProvider;
+var Viewport = ToastViewport;
+var Root2 = Toast;
+var Title = ToastTitle;
+var Description = ToastDescription;
+var Action = ToastAction;
+var Close = ToastClose;
+
+exports.Action = Action;
+exports.Close = Close;
+exports.Description = Description;
+exports.Provider = Provider;
+exports.Root = Root2;
+exports.Title = Title;
+exports.Toast = Toast;
+exports.ToastAction = ToastAction;
+exports.ToastClose = ToastClose;
+exports.ToastDescription = ToastDescription;
+exports.ToastProvider = ToastProvider;
+exports.ToastTitle = ToastTitle;
+exports.ToastViewport = ToastViewport;
+exports.Viewport = Viewport;
+//# sourceMappingURL=index.js.map