@tamagui/toast 1.7.11 → 1.8.1

package/dist/jsx/Toast.mjs

@@ -1,441 +1,79 @@
-import { useComposedRefs } from "@tamagui/compose-refs";
 import {
   composeEventHandlers,
-  isWeb,
+  styled,
+  themeable,
   useEvent,
-  useIsomorphicLayoutEffect
+  useId,
+  withStaticProperties
 } from "@tamagui/core";
-import { Portal } from "@tamagui/portal";
-import { YStack } from "@tamagui/stacks";
+import { ThemeableStack } from "@tamagui/stacks";
+import { SizableText } from "@tamagui/text";
 import { useControllableState } from "@tamagui/use-controllable-state";
-import { VisuallyHidden } from "@tamagui/visually-hidden";
 import * as React from "react";
-import * as ReactDOM from "react-dom";
-const PROVIDER_NAME = "ToastProvider";
-const [ToastProviderProvider, useToastProviderContext] = [];
-const ToastProvider = (props) => {
-  const {
-    __scopeToast,
-    label = "Notification",
-    duration = 5e3,
-    swipeDirection = "right",
-    swipeThreshold = 50,
-    children
-  } = props;
-  const [viewport, setViewport] = React.useState(null);
-  const [toastCount, setToastCount] = React.useState(0);
-  const isFocusedToastEscapeKeyDownRef = React.useRef(false);
-  const isClosePausedRef = React.useRef(false);
-  return (
-    // <Collection.Provider scope={__scopeToast}>
-    <ToastProviderProvider
-      scope={__scopeToast}
-      label={label}
-      duration={duration}
-      swipeDirection={swipeDirection}
-      swipeThreshold={swipeThreshold}
-      toastCount={toastCount}
-      viewport={viewport}
-      onViewportChange={setViewport}
-      onToastAdd={React.useCallback(
-        () => setToastCount((prevCount) => prevCount + 1),
-        []
-      )}
-      onToastRemove={React.useCallback(
-        () => setToastCount((prevCount) => prevCount - 1),
-        []
-      )}
-      isFocusedToastEscapeKeyDownRef={isFocusedToastEscapeKeyDownRef}
-      isClosePausedRef={isClosePausedRef}
-    >{children}</ToastProviderProvider>
-  );
-};
-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;
-const VIEWPORT_NAME = "ToastViewport";
-const VIEWPORT_DEFAULT_HOTKEY = ["F8"];
-const VIEWPORT_PAUSE = "toast.viewportPause";
-const VIEWPORT_RESUME = "toast.viewportResume";
-const ToastViewport = React.forwardRef(
-  (props, forwardedRef) => {
-    const {
-      __scopeToast,
-      hotkey = VIEWPORT_DEFAULT_HOTKEY,
-      label = "Notifications ({hotkey})",
-      ...viewportProps
-    } = props;
-    const context = useToastProviderContext(VIEWPORT_NAME, __scopeToast);
-    const wrapperRef = React.useRef(null);
-    const headFocusProxyRef = React.useRef(null);
-    const tailFocusProxyRef = React.useRef(null);
-    const ref = React.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref, context.onViewportChange);
-    const hotkeyLabel = hotkey.join("+").replace(/Key/g, "").replace(/Digit/g, "");
-    const hasToasts = context.toastCount > 0;
-    React.useEffect(() => {
-      const handleKeyDown = (event) => {
-        const isHotkeyPressed = hotkey.every(
-          (key) => event[key] || event.code === key
-        );
-        if (isHotkeyPressed)
-          ref.current?.focus();
-      };
-      document.addEventListener("keydown", handleKeyDown);
-      return () => document.removeEventListener("keydown", handleKeyDown);
-    }, [hotkey]);
-    React.useEffect(() => {
-      const wrapper = wrapperRef.current;
-      const viewport = ref.current;
-      if (wrapper && viewport) {
-        const handlePause = () => {
-          const pauseEvent = new CustomEvent(VIEWPORT_PAUSE);
-          context.isClosePausedRef.current = true;
-        };
-        const handleResume = () => {
-          const resumeEvent = new CustomEvent(VIEWPORT_RESUME);
-          context.isClosePausedRef.current = false;
-        };
-        wrapper.addEventListener("focusin", handlePause);
-        wrapper.addEventListener("focusout", handleResume);
-        wrapper.addEventListener("pointerenter", handlePause);
-        wrapper.addEventListener("pointerleave", handleResume);
-        window.addEventListener("blur", handlePause);
-        window.addEventListener("focus", handleResume);
-        return () => {
-          wrapper.removeEventListener("focusin", handlePause);
-          wrapper.removeEventListener("focusout", handleResume);
-          wrapper.removeEventListener("pointerenter", handlePause);
-          wrapper.removeEventListener("pointerleave", handleResume);
-          window.removeEventListener("blur", handlePause);
-          window.removeEventListener("focus", handleResume);
-        };
-      }
-    }, [context.isClosePausedRef]);
-    React.useEffect(
-      () => {
-        const viewport = ref.current;
-        if (viewport) {
-          const handleKeyDown = (event) => {
-            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) {
-                headFocusProxyRef.current?.focus();
-                return;
-              }
-              const tabbingDirection = isTabbingBackwards ? "backwards" : "forwards";
-            }
-          };
-          return () => {
-          };
-        }
-      },
-      [
-        // getItems, getSortedTabbableCandidates
-      ]
-    );
-    return null;
-  }
-);
-ToastViewport.displayName = VIEWPORT_NAME;
-const FOCUS_PROXY_NAME = "ToastFocusProxy";
-const FocusProxy = React.forwardRef(
-  (props, forwardedRef) => {
-    const { __scopeToast, onFocusFromOutsideViewport, ...proxyProps } = props;
-    const context = useToastProviderContext(FOCUS_PROXY_NAME, __scopeToast);
-    return <VisuallyHidden
-      aria-hidden
-      tabIndex={0}
-      {...proxyProps}
-      ref={forwardedRef}
-      position={isWeb ? "fixed" : "absolute"}
-      onFocus={(event) => {
-        const prevFocusedElement = event.relatedTarget;
-        const isFocusFromOutsideViewport = !context.viewport?.contains(prevFocusedElement);
-        if (isFocusFromOutsideViewport)
-          onFocusFromOutsideViewport();
-      }}
-    />;
-  }
-);
-FocusProxy.displayName = FOCUS_PROXY_NAME;
-const TOAST_NAME = "Toast";
-const TOAST_SWIPE_START = "toast.swipeStart";
-const TOAST_SWIPE_MOVE = "toast.swipeMove";
-const TOAST_SWIPE_CANCEL = "toast.swipeCancel";
-const TOAST_SWIPE_END = "toast.swipeEnd";
-const Toast = React.forwardRef(
-  (props, forwardedRef) => {
-    const {
-      forceMount,
-      open: openProp,
-      defaultOpen,
-      onOpenChange,
-      ...toastProps
-    } = props;
-    const [open, setOpen] = useControllableState({
-      prop: openProp,
-      defaultProp: true,
-      onChange: onOpenChange,
-      transition: true
-    });
-    return (
-      // <Presence present={forceMount || open}>
-      <ToastImpl
-        open={open}
-        {...toastProps}
-        ref={forwardedRef}
-        onClose={() => setOpen(false)}
-      />
-    );
-  }
-);
-Toast.displayName = TOAST_NAME;
-const [ToastInteractiveProvider, useToastInteractiveContext] = {};
-const ToastImpl = React.forwardRef(
-  (props, forwardedRef) => {
-    const {
-      __scopeToast,
-      type = "foreground",
-      duration: durationProp,
-      open,
-      onClose,
-      onEscapeKeyDown,
-      onSwipeStart,
-      onSwipeMove,
-      onSwipeCancel,
-      onSwipeEnd,
-      ...toastProps
-    } = props;
-    const context = useToastProviderContext(TOAST_NAME, __scopeToast);
-    const ref = React.useRef(null);
-    const composedRefs = useComposedRefs(forwardedRef, ref);
-    const pointerStartRef = React.useRef(null);
-    const swipeDeltaRef = React.useRef(null);
-    const duration = durationProp || context.duration;
-    const closeTimerStartTimeRef = React.useRef(0);
-    const closeTimerRemainingTimeRef = React.useRef(duration);
-    const closeTimerRef = React.useRef(0);
-    const { onToastAdd, onToastRemove } = context;
-    const handleClose = useEvent(() => {
-      onClose();
-    });
-    const startTimer = React.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.useEffect(() => {
-      const viewport = context.viewport;
-      if (viewport) {
-        const handleResume = () => {
-          startTimer(closeTimerRemainingTimeRef.current);
-        };
-        const handlePause = () => {
-          const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - closeTimerStartTimeRef.current;
-          closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime;
-          window.clearTimeout(closeTimerRef.current);
-        };
-        viewport.addEventListener(VIEWPORT_PAUSE, handlePause);
-        viewport.addEventListener(VIEWPORT_RESUME, handleResume);
-        return () => {
-          viewport.removeEventListener(VIEWPORT_PAUSE, handlePause);
-          viewport.removeEventListener(VIEWPORT_RESUME, handleResume);
-        };
+import { TOAST_NAME } from "./constants";
+import { createToast } from "./createToast";
+import { ToastAnnounceExclude } from "./ToastAnnounce";
+import {
+  ToastImpl,
+  ToastImplFrame,
+  useToastInteractiveContext
+} from "./ToastImpl";
+import {
+  ToastProvider,
+  createToastScope
+} from "./ToastProvider";
+import { ToastViewport } from "./ToastViewport";
+const TITLE_NAME = "ToastTitle";
+const ToastTitleFrame = styled(SizableText, {
+  name: TITLE_NAME,
+  color: "$color",
+  variants: {
+    unstyled: {
+      false: {
+        size: "$4"
       }
-    }, [context.viewport, duration, startTimer]);
-    React.useEffect(() => {
-      if (open && !context.isClosePausedRef.current)
-        startTimer(duration);
-    }, [open, duration, context.isClosePausedRef, startTimer]);
-    React.useEffect(() => {
-      onToastAdd();
-      return () => onToastRemove();
-    }, [onToastAdd, onToastRemove]);
-    if (!context.viewport)
-      return null;
-    return <>
-      <ToastAnnounce
-        __scopeToast={__scopeToast}
-        role="status"
-        aria-live={type === "foreground" ? "assertive" : "polite"}
-        aria-atomic
-      >{props.children}</ToastAnnounce>
-      <ToastInteractiveProvider
-        scope={__scopeToast}
-        isInteractive
-        onClose={handleClose}
-      >{ReactDOM.createPortal(
-        <div />,
-        // <Collection.ItemSlot scope={__scopeToast}>
-        // <DismissableLayer.Root
-        //   asChild
-        //   onEscapeKeyDown={composeEventHandlers(onEscapeKeyDown, () => {
-        //     if (!context.isFocusedToastEscapeKeyDownRef.current) handleClose()
-        //     context.isFocusedToastEscapeKeyDownRef.current = false
-        //   })}
-        // >
-        // <Primitive.li
-        //   // Ensure toasts are announced as status list or status when focused
-        //   role="status"
-        //   aria-live="off"
-        //   aria-atomic
-        //   tabIndex={0}
-        //   data-state={open ? 'open' : 'closed'}
-        //   data-swipe-direction={context.swipeDirection}
-        //   {...toastProps}
-        //   ref={composedRefs}
-        //   style={{ userSelect: 'none', touchAction: 'none', ...props.style }}
-        //   onKeyDown={composeEventHandlers(props.onKeyDown, (event) => {
-        //     if (event.key !== 'Escape') return
-        //     onEscapeKeyDown?.(event.nativeEvent)
-        //     if (!event.nativeEvent.defaultPrevented) {
-        //       context.isFocusedToastEscapeKeyDownRef.current = true
-        //       handleClose()
-        //     }
-        //   })}
-        //   onPointerDown={composeEventHandlers(props.onPointerDown, (event) => {
-        //     if (event.button !== 0) return
-        //     pointerStartRef.current = { x: event.clientX, y: event.clientY }
-        //   })}
-        //   onPointerMove={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 as HTMLElement).setPointerCapture(event.pointerId)
-        //     } else if (Math.abs(x) > moveStartBuffer || Math.abs(y) > moveStartBuffer) {
-        //       // User is swiping in wrong direction so we disable swipe gesture
-        //       // for the current pointer down interaction
-        //       pointerStartRef.current = null
-        //     }
-        //   })}
-        //   onPointerUp={composeEventHandlers(props.onPointerUp, (event) => {
-        //     const delta = swipeDeltaRef.current
-        //     ;(event.target as HTMLElement).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,
-        //         })
-        //       }
-        //       // Prevent click event from triggering on items within the toast when
-        //       // pointer up is part of a swipe gesture
-        //       toast.addEventListener('click', (event) => event.preventDefault(), {
-        //         once: true,
-        //       })
-        //     }
-        //   })}
-        // />
-        // </DismissableLayer.Root>,
-        // </Collection.ItemSlot>,
-        context.viewport
-      )}</ToastInteractiveProvider>
-    </>;
-  }
-);
-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;
+  },
+  defaultVariants: {
+    unstyled: false
   }
-};
-const ToastAnnounce = (props) => {
-  const { __scopeToast, children, ...announceProps } = props;
-  const context = useToastProviderContext(TOAST_NAME, __scopeToast);
-  const [renderAnnounceText, setRenderAnnounceText] = React.useState(false);
-  const [isAnnounced, setIsAnnounced] = React.useState(false);
-  const [fragment, setFragment] = React.useState();
-  const [rootFragmentNode, setRootFragmentNode] = React.useState(null);
-  const announceTextContent = React.useMemo(() => {
-    return rootFragmentNode ? getAnnounceTextContent(rootFragmentNode) : null;
-  }, [rootFragmentNode]);
-  useIsomorphicLayoutEffect(() => {
-    setFragment(new DocumentFragment());
-  }, []);
-  useNextFrame(() => setRenderAnnounceText(true));
-  React.useEffect(() => {
-    const timer = window.setTimeout(() => setIsAnnounced(true), 1e3);
-    return () => window.clearTimeout(timer);
-  }, []);
-  return isAnnounced ? null : <>
-    {fragment && // @ts-ignore
-    <Portal container={fragment} ref={setRootFragmentNode}>
-      {context.label}
-      {" "}
-      {children}
-    </Portal>}
-    <Portal asChild><VisuallyHidden {...announceProps}>{renderAnnounceText && announceTextContent}</VisuallyHidden></Portal>
-  </>;
-};
-const TITLE_NAME = "ToastTitle";
+});
 const ToastTitle = React.forwardRef(
   (props, forwardedRef) => {
     const { __scopeToast, ...titleProps } = props;
-    return <YStack {...titleProps} ref={forwardedRef} />;
+    return <ToastTitleFrame {...titleProps} ref={forwardedRef} />;
   }
 );
 ToastTitle.displayName = TITLE_NAME;
 const DESCRIPTION_NAME = "ToastDescription";
-const ToastDescription = React.forwardRef((props, forwardedRef) => {
-  const { __scopeToast, ...descriptionProps } = props;
-  return <YStack {...descriptionProps} ref={forwardedRef} />;
+const ToastDescriptionFrame = styled(SizableText, {
+  name: DESCRIPTION_NAME,
+  color: "$color11",
+  variants: {
+    unstyled: {
+      false: {
+        size: "$1"
+      }
+    }
+  },
+  defaultVariants: {
+    unstyled: false
+  }
 });
+const ToastDescription = React.forwardRef(
+  (props, forwardedRef) => {
+    const { __scopeToast, ...descriptionProps } = props;
+    return <ToastDescriptionFrame {...descriptionProps} ref={forwardedRef} />;
+  }
+);
 ToastDescription.displayName = DESCRIPTION_NAME;
 const ACTION_NAME = "ToastAction";
 const ToastAction = React.forwardRef(
   (props, forwardedRef) => {
     const { altText, ...actionProps } = props;
-    const context = useToastInteractiveContext(ACTION_NAME, props.__scopeToast);
     if (!altText)
       return null;
-    return context.isInteractive ? <ToastClose {...actionProps} ref={forwardedRef} /> : <span>{altText}</span>;
+    return <ToastAnnounceExclude altText={altText} asChild><ToastClose {...actionProps} ref={forwardedRef} /></ToastAnnounceExclude>;
   }
 );
 ToastAction.propTypes = {
@@ -448,115 +86,65 @@ ToastAction.propTypes = {
 };
 ToastAction.displayName = ACTION_NAME;
 const CLOSE_NAME = "ToastClose";
+const ToastCloseFrame = styled(ThemeableStack, {
+  name: CLOSE_NAME,
+  tag: "button"
+});
 const ToastClose = React.forwardRef(
   (props, forwardedRef) => {
     const { __scopeToast, ...closeProps } = props;
     const interactiveContext = useToastInteractiveContext(CLOSE_NAME, __scopeToast);
-    return interactiveContext.isInteractive ? <YStack
-      tag="button"
+    return <ToastAnnounceExclude asChild><ToastCloseFrame
+      accessibilityLabel="Dialog Close"
       {...closeProps}
       ref={forwardedRef}
       onPress={composeEventHandlers(props.onPress, interactiveContext.onClose)}
-    /> : null;
+    /></ToastAnnounceExclude>;
   }
 );
 ToastClose.displayName = CLOSE_NAME;
-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) {
-  } else {
-    currentTarget.dispatchEvent(event);
-  }
-}
-const 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;
+const ToastComponent = React.forwardRef(
+  ToastImplFrame.extractable((props, forwardedRef) => {
+    const { forceMount, open: openProp, defaultOpen, onOpenChange, ...toastProps } = props;
+    const [open, setOpen] = useControllableState({
+      prop: openProp,
+      defaultProp: defaultOpen ?? true,
+      onChange: onOpenChange
+    });
+    const id = useId();
+    const onPause = useEvent(props.onPause);
+    const onResume = useEvent(props.onResume);
+    if (!forceMount && !open)
+      return null;
+    return <ToastImpl
+      id={id}
+      open={open}
+      {...toastProps}
+      ref={forwardedRef}
+      onClose={() => setOpen(false)}
+      onPause={onPause}
+      onResume={onResume}
+      onSwipeEnd={composeEventHandlers(props.onSwipeEnd, (event) => {
+        setOpen(false);
+      })}
+    />;
+  })
+);
+ToastComponent.displayName = TOAST_NAME;
+const Toast = withStaticProperties(
+  themeable(ToastComponent, ToastImplFrame.staticConfig),
+  {
+    Title: ToastTitle,
+    Description: ToastDescription,
+    Action: ToastAction,
+    Close: ToastClose
   }
-};
-function useNextFrame(callback = () => {
-}) {
-  const fn = useEvent(callback);
-  useIsomorphicLayoutEffect(() => {
-    let raf1 = 0;
-    let raf2 = 0;
-    raf1 = window.requestAnimationFrame(
-      () => raf2 = window.requestAnimationFrame(fn)
-    );
-    return () => {
-      window.cancelAnimationFrame(raf1);
-      window.cancelAnimationFrame(raf2);
-    };
-  }, [fn]);
-}
-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";
-      if (!isHidden)
-        textContent.push(...getAnnounceTextContent(node));
-    }
-  });
-  return textContent;
-}
-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;
-  });
-}
-const Provider = ToastProvider;
-const Viewport = ToastViewport;
-const Root = Toast;
-const Title = ToastTitle;
-const Description = ToastDescription;
-const Action = ToastAction;
-const Close = ToastClose;
+);
 export {
-  Action,
-  Close,
-  Description,
-  Provider,
-  Root,
-  Title,
   Toast,
-  ToastAction,
-  ToastClose,
-  ToastDescription,
   ToastProvider,
-  ToastTitle,
   ToastViewport,
-  Viewport
+  createToast,
+  createToastScope
 };
 //# sourceMappingURL=Toast.mjs.map