@tamagui/toast 1.88.13 → 1.89.0-1706308641099

package/dist/esm/Toast.mjs

@@ -0,0 +1,126 @@
+import { styled, useEvent } from "@tamagui/core";
+import { composeEventHandlers, withStaticProperties } from "@tamagui/helpers";
+import { ThemeableStack } from "@tamagui/stacks";
+import { SizableText } from "@tamagui/text";
+import { useControllableState } from "@tamagui/use-controllable-state";
+import * as React from "react";
+import { TOAST_NAME } from "./constants.mjs";
+import { ToastAnnounceExclude } from "./ToastAnnounce.mjs";
+import { useToast, useToastController, useToastState } from "./ToastImperative.mjs";
+import { ToastImpl, ToastImplFrame, useToastInteractiveContext } from "./ToastImpl.mjs";
+import { ToastProvider } from "./ToastProvider.mjs";
+import { ToastViewport } from "./ToastViewport.mjs";
+import { jsx } from "react/jsx-runtime";
+const TITLE_NAME = "ToastTitle",
+  ToastTitle = styled(SizableText, {
+    name: TITLE_NAME,
+    variants: {
+      unstyled: {
+        false: {
+          color: "$color",
+          size: "$4"
+        }
+      }
+    },
+    defaultVariants: {
+      unstyled: process.env.TAMAGUI_HEADLESS === "1"
+    }
+  });
+ToastTitle.displayName = TITLE_NAME;
+const DESCRIPTION_NAME = "ToastDescription",
+  ToastDescription = styled(SizableText, {
+    name: DESCRIPTION_NAME,
+    variants: {
+      unstyled: {
+        false: {
+          color: "$color11",
+          size: "$1"
+        }
+      }
+    },
+    defaultVariants: {
+      unstyled: process.env.TAMAGUI_HEADLESS === "1"
+    }
+  });
+ToastDescription.displayName = DESCRIPTION_NAME;
+const ACTION_NAME = "ToastAction",
+  ToastAction = React.forwardRef((props, forwardedRef) => {
+    const {
+      altText,
+      ...actionProps
+    } = props;
+    return altText ? /* @__PURE__ */jsx(ToastAnnounceExclude, {
+      altText,
+      asChild: !0,
+      children: /* @__PURE__ */jsx(ToastClose, {
+        ...actionProps,
+        ref: forwardedRef
+      })
+    }) : null;
+  });
+ToastAction.propTypes = {
+  altText(props) {
+    return props.altText ? null : new Error(`Missing prop \`altText\` expected on \`${ACTION_NAME}\``);
+  }
+};
+ToastAction.displayName = ACTION_NAME;
+const CLOSE_NAME = "ToastClose",
+  ToastCloseFrame = styled(ThemeableStack, {
+    name: CLOSE_NAME,
+    tag: "button"
+  }),
+  ToastClose = React.forwardRef((props, forwardedRef) => {
+    const {
+        __scopeToast,
+        ...closeProps
+      } = props,
+      interactiveContext = useToastInteractiveContext(__scopeToast);
+    return /* @__PURE__ */jsx(ToastAnnounceExclude, {
+      asChild: !0,
+      children: /* @__PURE__ */jsx(ToastCloseFrame, {
+        accessibilityLabel: "Dialog Close",
+        ...closeProps,
+        ref: forwardedRef,
+        onPress: composeEventHandlers(props.onPress, interactiveContext.onClose)
+      })
+    });
+  });
+ToastClose.displayName = CLOSE_NAME;
+const ToastComponent = ToastImplFrame.styleable((props, forwardedRef) => {
+  const {
+      forceMount,
+      open: openProp,
+      defaultOpen,
+      onOpenChange,
+      ...toastProps
+    } = props,
+    [open, setOpen] = useControllableState({
+      prop: openProp,
+      defaultProp: defaultOpen ?? !0,
+      onChange: onOpenChange,
+      strategy: "most-recent-wins"
+    }),
+    id = React.useId(),
+    onPause = useEvent(props.onPause),
+    onResume = useEvent(props.onResume);
+  return forceMount || open ? /* @__PURE__ */jsx(ToastImpl, {
+    id,
+    open,
+    ...toastProps,
+    ref: forwardedRef,
+    onClose: () => setOpen(!1),
+    onPause,
+    onResume,
+    onSwipeEnd: composeEventHandlers(props.onSwipeEnd, event => {
+      setOpen(!1);
+    })
+  }) : null;
+});
+ToastComponent.displayName = TOAST_NAME;
+const Toast = withStaticProperties(ToastComponent, {
+  Title: ToastTitle,
+  Description: ToastDescription,
+  Action: ToastAction,
+  Close: ToastClose
+});
+export { Toast, ToastProvider, ToastViewport, useToast, useToastController, useToastState };

package/dist/esm/ToastAnnounce.mjs

@@ -0,0 +1,57 @@
+import { useIsomorphicLayoutEffect } from "@tamagui/constants";
+import { Stack, Text, styled, useEvent } from "@tamagui/core";
+import { Portal } from "@tamagui/portal";
+import { VisuallyHidden } from "@tamagui/visually-hidden";
+import * as React from "react";
+import { useToastProviderContext } from "./ToastProvider.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+const ToastAnnounceExcludeFrame = styled(Stack, {
+    name: "ToastAnnounceExclude"
+  }),
+  ToastAnnounceExclude = React.forwardRef((props, forwardedRef) => {
+    const {
+      altText,
+      ...announceExcludeProps
+    } = props;
+    return /* @__PURE__ */jsx(ToastAnnounceExcludeFrame, {
+      "data-toast-announce-exclude": "",
+      "data-toast-announce-alt": altText || void 0,
+      ...announceExcludeProps,
+      ref: forwardedRef
+    });
+  }),
+  ToastAnnounce = props => {
+    const {
+        __scopeToast,
+        children,
+        ...announceProps
+      } = props,
+      context = useToastProviderContext(__scopeToast),
+      [renderAnnounceText, setRenderAnnounceText] = React.useState(!1),
+      [isAnnounced, setIsAnnounced] = React.useState(!1);
+    return useNextFrame(() => setRenderAnnounceText(!0)), React.useEffect(() => {
+      const timer = setTimeout(() => setIsAnnounced(!0), 1e3);
+      return () => clearTimeout(timer);
+    }, []), isAnnounced ? null : /* @__PURE__ */jsx(Portal, {
+      asChild: !0,
+      children: /* @__PURE__ */jsx(VisuallyHidden, {
+        ...announceProps,
+        children: renderAnnounceText && /* @__PURE__ */jsxs(Text, {
+          children: [context.label, " ", children]
+        })
+      })
+    });
+  };
+function useNextFrame(callback = () => {}) {
+  const fn = useEvent(callback);
+  useIsomorphicLayoutEffect(() => {
+    let raf1 = 0,
+      raf2 = 0;
+    return raf1 = requestAnimationFrame(() => {
+      raf2 = requestAnimationFrame(fn);
+    }), () => {
+      cancelAnimationFrame(raf1), cancelAnimationFrame(raf2);
+    };
+  }, [fn]);
+}
+export { ToastAnnounce, ToastAnnounceExclude };

package/dist/esm/ToastImperative.mjs

@@ -0,0 +1,58 @@
+import { isWeb } from "@tamagui/core";
+import React, { createContext, useContext, useMemo, useRef } from "react";
+import { Platform } from "react-native-web";
+import { createNativeToast } from "./createNativeToast.mjs";
+import { jsx } from "react/jsx-runtime";
+const ToastContext = createContext({}),
+  ToastCurrentContext = createContext(null),
+  useToastController = () => useContext(ToastContext),
+  useToastState = () => useContext(ToastCurrentContext),
+  useToast = () => ({
+    ...useToastController(),
+    currentToast: useToastState()
+  }),
+  ToastImperativeProvider = ({
+    children,
+    options
+  }) => {
+    const counterRef = useRef(0),
+      [toast, setToast] = React.useState(null),
+      [lastNativeToastRef, setLastNativeToastRef] = React.useState(null),
+      show = React.useCallback((title, showOptions) => {
+        const native = showOptions?.native ?? options.native,
+          isWebNative = Array.isArray(native) ? native.includes("web") : native === "web",
+          isMobileNative = Array.isArray(native) ? native.includes("mobile") : native === "mobile",
+          isAndroidNative = isMobileNative || (Array.isArray(native) ? native.includes("android") : native === "android"),
+          isIosNative = isMobileNative || (Array.isArray(native) ? native.includes("ios") : native === "ios"),
+          isHandledNatively = native === !0 || isWeb && isWebNative || !isWeb && isMobileNative || Platform.OS === "android" && isAndroidNative || Platform.OS === "ios" && isIosNative;
+        if (isHandledNatively) {
+          const nativeToastResult = createNativeToast(title, showOptions ?? {});
+          typeof nativeToastResult == "object" && nativeToastResult.nativeToastRef && setLastNativeToastRef(nativeToastResult.nativeToastRef);
+        }
+        return counterRef.current++, setToast({
+          ...showOptions?.customData,
+          ...showOptions,
+          viewportName: showOptions?.viewportName ?? "default",
+          title,
+          id: counterRef.current.toString(),
+          isHandledNatively
+        }), !0;
+      }, [setToast, options.native]),
+      hide = React.useCallback(() => {
+        lastNativeToastRef?.close(), setToast(null);
+      }, [setToast, lastNativeToastRef]),
+      contextValue = useMemo(() => ({
+        show,
+        hide,
+        nativeToast: lastNativeToastRef,
+        options
+      }), [show, hide, lastNativeToastRef, JSON.stringify(options || null)]);
+    return /* @__PURE__ */jsx(ToastContext.Provider, {
+      value: contextValue,
+      children: /* @__PURE__ */jsx(ToastCurrentContext.Provider, {
+        value: toast,
+        children
+      })
+    });
+  };
+export { ToastImperativeProvider, useToast, useToastController, useToastState };

package/dist/esm/ToastImpl.mjs

@@ -0,0 +1,251 @@
+import { useIsPresent } from "@tamagui/animate-presence";
+import { useComposedRefs } from "@tamagui/compose-refs";
+import { isWeb } from "@tamagui/constants";
+import { Stack, Theme, createStyledContext, styled, useConfiguration, useEvent, useThemeName } from "@tamagui/core";
+import { Dismissable } from "@tamagui/dismissable";
+import { composeEventHandlers } from "@tamagui/helpers";
+import { PortalItem } from "@tamagui/portal";
+import { ThemeableStack } from "@tamagui/stacks";
+import * as React from "react";
+import { PanResponder } from "react-native-web";
+import { TOAST_CONTEXT, TOAST_NAME } from "./constants.mjs";
+import { ToastAnnounce } from "./ToastAnnounce.mjs";
+import { Collection, useToastProviderContext } from "./ToastProvider.mjs";
+import { VIEWPORT_PAUSE, VIEWPORT_RESUME } from "./ToastViewport.mjs";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+const ToastImplFrame = styled(ThemeableStack, {
+    name: "ToastImpl",
+    focusable: !0,
+    variants: {
+      unstyled: {
+        false: {
+          focusStyle: {
+            outlineStyle: "solid",
+            outlineWidth: 2,
+            outlineColor: "$outlineColor"
+          },
+          backgroundColor: "$color6",
+          borderRadius: "$10",
+          paddingHorizontal: "$5",
+          paddingVertical: "$2",
+          marginHorizontal: "auto",
+          marginVertical: "$1"
+        }
+      }
+    },
+    defaultVariants: {
+      unstyled: process.env.TAMAGUI_HEADLESS === "1"
+    }
+  }),
+  {
+    Provider: ToastInteractiveProvider,
+    useStyledContext: useToastInteractiveContext
+  } = createStyledContext({
+    onClose() {}
+  }),
+  ToastImpl = React.forwardRef((props, forwardedRef) => {
+    const {
+        __scopeToast,
+        type = "foreground",
+        duration: durationProp,
+        open,
+        onClose,
+        onEscapeKeyDown,
+        onPause,
+        onResume,
+        onSwipeStart,
+        onSwipeMove,
+        onSwipeCancel,
+        onSwipeEnd,
+        viewportName = "default",
+        ...toastProps
+      } = props,
+      isPresent = useIsPresent(),
+      context = useToastProviderContext(__scopeToast),
+      [node, setNode] = React.useState(null),
+      composedRefs = useComposedRefs(forwardedRef, node2 => setNode(node2)),
+      duration = durationProp || context.duration,
+      closeTimerStartTimeRef = React.useRef(0),
+      closeTimerRemainingTimeRef = React.useRef(duration),
+      closeTimerRef = React.useRef(0),
+      {
+        onToastAdd,
+        onToastRemove
+      } = context,
+      viewport = React.useMemo(() => context.viewports[viewportName], [context.viewports, viewportName]),
+      handleClose = useEvent(() => {
+        isPresent && (isWeb && node?.contains(document.activeElement) && viewport?.focus(), onClose());
+      }),
+      startTimer = React.useCallback(duration2 => {
+        !duration2 || duration2 === 1 / 0 || (clearTimeout(closeTimerRef.current), closeTimerStartTimeRef.current = /* @__PURE__ */new Date().getTime(), closeTimerRef.current = setTimeout(handleClose, duration2));
+      }, [handleClose]),
+      handleResume = React.useCallback(() => {
+        startTimer(closeTimerRemainingTimeRef.current), onResume?.();
+      }, [onResume, startTimer]),
+      handlePause = React.useCallback(() => {
+        const elapsedTime = /* @__PURE__ */new Date().getTime() - closeTimerStartTimeRef.current;
+        closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime, window.clearTimeout(closeTimerRef.current), onPause?.();
+      }, [onPause]);
+    React.useEffect(() => {
+      if (isWeb && viewport) return viewport.addEventListener(VIEWPORT_PAUSE, handlePause), viewport.addEventListener(VIEWPORT_RESUME, handleResume), () => {
+        viewport.removeEventListener(VIEWPORT_PAUSE, handlePause), viewport.removeEventListener(VIEWPORT_RESUME, handleResume);
+      };
+    }, [viewport, duration, onPause, onResume, startTimer]), React.useEffect(() => {
+      open && !context.isClosePausedRef.current && startTimer(duration);
+    }, [open, duration, context.isClosePausedRef, startTimer]), React.useEffect(() => (onToastAdd(), () => onToastRemove()), [onToastAdd, onToastRemove]);
+    const announceTextContent = React.useMemo(() => isWeb && node ? getAnnounceTextContent(node) : null, [node]),
+      isHorizontalSwipe = ["left", "right", "horizontal"].includes(context.swipeDirection),
+      {
+        animationDriver
+      } = useConfiguration();
+    if (!animationDriver) throw new Error("Must set animations in tamagui.config.ts");
+    const {
+        useAnimatedNumber,
+        useAnimatedNumberStyle
+      } = animationDriver,
+      animatedNumber = useAnimatedNumber(0),
+      AnimatedView = animationDriver.NumberView ?? animationDriver.View ?? Stack,
+      animatedStyles = useAnimatedNumberStyle(animatedNumber, val => {
+        "worklet";
+
+        return {
+          transform: [isHorizontalSwipe ? {
+            translateX: val
+          } : {
+            translateY: val
+          }]
+        };
+      }),
+      panResponder = React.useMemo(() => PanResponder.create({
+        onMoveShouldSetPanResponder: (e, gesture) => shouldGrantGestureMove(context.swipeDirection, gesture) ? (onSwipeStart?.(e), !0) : !1,
+        onPanResponderGrant: e => {
+          isWeb || handlePause?.();
+        },
+        onPanResponderMove: (e, gesture) => {
+          const {
+              x,
+              y
+            } = getGestureDistance(context.swipeDirection, gesture),
+            delta = {
+              x,
+              y
+            };
+          animatedNumber.setValue(isHorizontalSwipe ? x : y, {
+            type: "direct"
+          }), isDeltaInDirection(delta, context.swipeDirection, context.swipeThreshold) && onSwipeEnd?.(e), onSwipeMove?.(e);
+        },
+        onPanResponderEnd: (e, {
+          dx,
+          dy
+        }) => {
+          isDeltaInDirection({
+            x: dx,
+            y: dy
+          }, context.swipeDirection, context.swipeThreshold) || (isWeb || handleResume?.(), onSwipeCancel?.(e), animatedNumber.setValue(0, {
+            type: "spring"
+          }));
+        }
+      }), [handlePause, handleResume]),
+      themeName = useThemeName();
+    return /* @__PURE__ */jsxs(Fragment, {
+      children: [announceTextContent && /* @__PURE__ */jsx(ToastAnnounce, {
+        __scopeToast,
+        role: "status",
+        "aria-live": type === "foreground" ? "assertive" : "polite",
+        "aria-atomic": !0,
+        children: announceTextContent
+      }), /* @__PURE__ */jsx(PortalItem, {
+        hostName: viewportName ?? "default",
+        children: /* @__PURE__ */jsx(ToastInteractiveProvider, {
+          scope: __scopeToast,
+          onClose: () => {
+            handleClose();
+          },
+          children: /* @__PURE__ */jsx(Dismissable, {
+            onEscapeKeyDown: composeEventHandlers(onEscapeKeyDown, () => {
+              context.isFocusedToastEscapeKeyDownRef.current || handleClose(), context.isFocusedToastEscapeKeyDownRef.current = !1;
+            }),
+            children: /* @__PURE__ */jsx(Theme, {
+              forceClassName: !0,
+              name: themeName,
+              children: /* @__PURE__ */jsx(AnimatedView, {
+                ...panResponder?.panHandlers,
+                style: [{
+                  margin: "auto"
+                }, animatedStyles],
+                children: /* @__PURE__ */jsx(Collection.ItemSlot, {
+                  __scopeCollection: __scopeToast || TOAST_CONTEXT,
+                  children: /* @__PURE__ */jsx(ToastImplFrame, {
+                    role: "status",
+                    "aria-live": "off",
+                    "aria-atomic": !0,
+                    "data-state": open ? "open" : "closed",
+                    "data-swipe-direction": context.swipeDirection,
+                    pointerEvents: "auto",
+                    touchAction: "none",
+                    userSelect: "none",
+                    ...toastProps,
+                    ref: composedRefs,
+                    ...(isWeb && {
+                      onKeyDown: composeEventHandlers(props.onKeyDown, event => {
+                        event.key === "Escape" && (onEscapeKeyDown?.(event), onEscapeKeyDown?.(event), event.defaultPrevented || (context.isFocusedToastEscapeKeyDownRef.current = !0, handleClose()));
+                      })
+                    })
+                  })
+                })
+              })
+            })
+          })
+        }, props.id)
+      })]
+    });
+  });
+ToastImpl.propTypes = {
+  type(props) {
+    if (props.type && !["foreground", "background"].includes(props.type)) {
+      const error = `Invalid prop \`type\` supplied to \`${TOAST_NAME}\`. Expected \`foreground | background\`.`;
+      return new Error(error);
+    }
+    return null;
+  }
+};
+const isDeltaInDirection = (delta, direction, threshold = 0) => {
+  const deltaX = Math.abs(delta.x),
+    deltaY = Math.abs(delta.y),
+    isDeltaX = deltaX > deltaY;
+  return direction === "left" || direction === "right" || direction === "horizontal" ? isDeltaX && deltaX > threshold : !isDeltaX && deltaY > threshold;
+};
+function getAnnounceTextContent(container) {
+  if (!isWeb) return "";
+  const textContent = [];
+  return Array.from(container.childNodes).forEach(node => {
+    if (node.nodeType === node.TEXT_NODE && node.textContent && textContent.push(node.textContent), isHTMLElement(node)) {
+      const isHidden = node.ariaHidden || node.hidden || node.style.display === "none",
+        isExcluded = node.dataset.toastAnnounceExclude === "";
+      if (!isHidden) if (isExcluded) {
+        const altText = node.dataset.toastAnnounceAlt;
+        altText && textContent.push(altText);
+      } else textContent.push(...getAnnounceTextContent(node));
+    }
+  }), textContent;
+}
+function isHTMLElement(node) {
+  return node.nodeType === node.ELEMENT_NODE;
+}
+const GESTURE_GRANT_THRESHOLD = 10,
+  shouldGrantGestureMove = (dir, {
+    dx,
+    dy
+  }) => (dir === "horizontal" || dir === "left") && dx < -GESTURE_GRANT_THRESHOLD || (dir === "horizontal" || dir === "right") && dx > GESTURE_GRANT_THRESHOLD || (dir === "vertical" || dir === "up") && dy > -GESTURE_GRANT_THRESHOLD || (dir === "vertical" || dir === "down") && dy < GESTURE_GRANT_THRESHOLD,
+  getGestureDistance = (dir, {
+    dx,
+    dy
+  }) => {
+    let y = 0,
+      x = 0;
+    return dir === "horizontal" ? x = dx : dir === "left" ? x = Math.min(0, dx) : dir === "right" ? x = Math.max(0, dx) : dir === "vertical" ? y = dy : dir === "up" ? y = Math.min(0, dy) : dir === "down" && (y = Math.max(0, dy)), {
+      x,
+      y
+    };
+  };
+export { ToastImpl, ToastImplFrame, useToastInteractiveContext };

package/dist/esm/ToastPortal.mjs

@@ -0,0 +1,18 @@
+import { Portal } from "@tamagui/portal";
+import { Platform } from "react-native-web";
+import { ReprogapateToastProvider, useToastProviderContext } from "./ToastProvider.mjs";
+import { jsx } from "react/jsx-runtime";
+function ToastPortal({
+  children,
+  zIndex
+}) {
+  let content = children;
+  return Platform.OS === "android" && (content = /* @__PURE__ */jsx(ReprogapateToastProvider, {
+    context: useToastProviderContext(),
+    children
+  })), /* @__PURE__ */jsx(Portal, {
+    zIndex: zIndex || 1e9,
+    children: content
+  });
+}
+export { ToastPortal };

package/dist/esm/ToastProvider.mjs

@@ -0,0 +1,98 @@
+import { createCollection } from "@tamagui/collection";
+import { createStyledContext } from "@tamagui/core";
+import * as React from "react";
+import { TOAST_CONTEXT } from "./constants.mjs";
+import { ToastImperativeProvider } from "./ToastImperative.mjs";
+import { jsx } from "react/jsx-runtime";
+const PROVIDER_NAME = "ToastProvider",
+  [Collection, useCollection] = createCollection("Toast"),
+  {
+    Provider: ToastProviderProvider,
+    useStyledContext: useToastProviderContext
+  } = createStyledContext(),
+  ToastProvider = props => {
+    const {
+        __scopeToast,
+        id: providedId,
+        burntOptions,
+        native,
+        notificationOptions,
+        label = "Notification",
+        duration = 5e3,
+        swipeDirection = "right",
+        swipeThreshold = 50,
+        children
+      } = props,
+      backupId = React.useId(),
+      id = providedId ?? backupId,
+      [viewports, setViewports] = React.useState({}),
+      [toastCount, setToastCount] = React.useState(0),
+      isFocusedToastEscapeKeyDownRef = React.useRef(!1),
+      isClosePausedRef = React.useRef(!1),
+      handleViewportChange = React.useCallback((name, viewport) => {
+        setViewports(prev => ({
+          ...prev,
+          [name]: viewport
+        }));
+      }, []),
+      options = React.useMemo(() => ({
+        duration,
+        burntOptions,
+        native,
+        notificationOptions
+      }), [JSON.stringify([duration, burntOptions, native, notificationOptions])]);
+    return /* @__PURE__ */jsx(Collection.Provider, {
+      __scopeCollection: __scopeToast || TOAST_CONTEXT,
+      children: /* @__PURE__ */jsx(ToastProviderProvider, {
+        scope: __scopeToast,
+        id,
+        label,
+        duration,
+        swipeDirection,
+        swipeThreshold,
+        toastCount,
+        viewports,
+        onViewportChange: handleViewportChange,
+        onToastAdd: React.useCallback(() => {
+          setToastCount(prevCount => prevCount + 1);
+        }, []),
+        onToastRemove: React.useCallback(() => {
+          setToastCount(prevCount => prevCount - 1);
+        }, []),
+        isFocusedToastEscapeKeyDownRef,
+        isClosePausedRef,
+        options,
+        children: /* @__PURE__ */jsx(ToastImperativeProvider, {
+          options,
+          children
+        })
+      })
+    });
+  };
+function ReprogapateToastProvider(props) {
+  const {
+    children,
+    context
+  } = props;
+  return /* @__PURE__ */jsx(Collection.Provider, {
+    __scopeCollection: TOAST_CONTEXT,
+    children: /* @__PURE__ */jsx(ToastProviderProvider, {
+      ...context,
+      children: /* @__PURE__ */jsx(ToastImperativeProvider, {
+        options: context.options,
+        children
+      })
+    })
+  });
+}
+ToastProvider.propTypes = {
+  label(props) {
+    if (props.label && typeof props.label == "string" && !props.label.trim()) {
+      const error = `Invalid prop \`label\` supplied to \`${PROVIDER_NAME}\`. Expected non-empty \`string\`.`;
+      return new Error(error);
+    }
+    return null;
+  }
+};
+ToastProvider.displayName = PROVIDER_NAME;
+export { Collection, ReprogapateToastProvider, ToastProvider, useCollection, useToastProviderContext };