Toast Notification

import {Toast, Toaster, createToaster} from "@qualcomm-ui/react/toast"

Usage Guidelines

Global Toaster

  1. Create a single toaster instance in a shared file and export it for use throughout your app.
import {createToaster} from "@qualcomm-ui/react/toast"

export const globalToaster = createToaster({
  overlap: true,
  position: "bottom-end",
})
  1. Import and render the simple Toaster component near the root of your application.
// shared/toaster.ts
import {Toaster} from "@qualcomm-ui/react/toast"

import {globalToaster} from "./shared"

function AppRoot() {
  return (
    <>
      <Toaster toaster={globalToaster} />
      {/* ...the rest of your app */}
    </>
  )
}

Alternatively, you can provide children to the Toaster component to customize the rendering of the toasts. If children are omitted, the default toast rendering is used.

// <Toaster /> is ultimately a shortcut for this:
<Toaster toaster={toaster}>
  {(toast) => {
    return (
      <Toast.Root key={toast.id}>
        <Toast.Heading>{toast.title}</Toast.Heading>
        <Toast.Description>{toast.description}</Toast.Description>
        <Toast.CloseButton />
      </Toast.Root>
    )
  }}
</Toaster>

Examples

Demos

Each demo uses its own <Toaster /> instance for demonstration. Note that multiple toaster instances may obscure other toasts in practice, so it's recommended to use a single toaster instance for your entire app.

With Action

Use the action property to add an action button to the toast.

toaster.create({
  action: {
    label: "Action",
    onClick: () => {
      window.alert("You clicked an action")
    },
  },
  description: "Toast Description",
  label: "Toast Label",
})

Toast Emphasis

Here's an example of each toast type.

Overlapping Toasts

By default, toasts are stacked on top of each other. To conserve space when rendering many toasts, set the overlap property to true in the toaster.create function.

const toaster = createToaster({
  overlap: true,
  placement: "bottom-end",
})

Toast Duration

Use the duration property to set the duration of the toast.

toaster.create({
  duration: 10000,
  label: "Task failed successfully",
  type: "success",
})

Persistent Toast

Set the type property to loading to make the toast stay on screen until dismissed.

toaster.create({
  label: "Persistent Toast",
  type: "loading",
})

Pause and Resume

Use the pause and resume methods on the toaster instance to pause and play the toast.

Pausing a toast prevents it from timing out, while resuming it will continue the timeout from the remaining duration.

Max Visible

Set the max prop on the createToaster function to define the maximum number of toasts that can be rendered at a time. Extra toasts will be queued and rendered when the number of visible toasts drops below the max.

const toaster = createToaster({
  max: 3,
  placement: "bottom-end",
})

Screen Placement

Toasts can be displayed on all four corners of a page. We recommend picking a single placement for your app, as this creates a consistent experience for your users.

const topToaster = createToaster({
  placement: "top-end",
})

const bottomToaster = createToaster({
  placement: "bottom-start",
})

API

In the following sections, the toaster instance is referred to as toaster.

ToastCreateOptions

These are the options passed to the toaster.createToast function.

PropTypeDefault
The action of the toast
{
label: string
onClick: () => void
}
Whether the toast is closable
boolean
true
The description of the toast.
| string
| ReactElement
The duration the toast will be visible, in milliseconds.
number
The unique id of the toast
string
The title of the toast.
| string
| ReactElement
The metadata of the toast. Use this to provide additional information about the toast for use in your own component
Record<
string,
any
>
Function called when the toast is visible
    (
    details: ToastStatusChangeDetails,
    ) => void
    The duration the toast will be visible, in milliseconds. Required for exit transitions.
    number
    200
    
    The type of the toast. Controls the color and icon of the toast.
    | 'success'
    | 'danger'
    | 'loading'
    | 'info'
    | 'warning'
    | 'neutral'
    Type
    {
    label: string
    onClick: () => void
    }
    Description
    The action of the toast
    Type
    boolean
    Description
    Whether the toast is closable
    Type
    | string
    | ReactElement
    Description
    The description of the toast.
    Type
    number
    Description
    The duration the toast will be visible, in milliseconds.
    Type
    string
    Description
    The unique id of the toast
    Type
    | string
    | ReactElement
    Description
    The title of the toast.
    Type
    Record<
    string,
    any
    >
    Description
    The metadata of the toast. Use this to provide additional information about the toast for use in your own component
    Type
    (
    details: ToastStatusChangeDetails,
    ) => void
    Description
    Function called when the toast is visible
      Type
      number
      Description
      The duration the toast will be visible, in milliseconds. Required for exit transitions.
      Type
      | 'success'
      | 'danger'
      | 'loading'
      | 'info'
      | 'warning'
      | 'neutral'
      Description
      The type of the toast. Controls the color and icon of the toast.

      ToasterCreateOptions

      Options passed to the createToaster function.

      PropTypeDefault
      The duration the toast will be visible, in milliseconds. By default, this is determined by the type of the toast.
      number
      The gap between the toasts
      number
      16
      
      The maximum number of toasts. When the number of toasts exceeds this limit, the new toasts are queued.
      number
      12
      
      The offset from the safe environment edge of the viewport
      | string
      | Record<
      | 'bottom'
      | 'left'
      | 'right'
      | 'top',
      string
      >
      "1rem"
      
      Whether to overlap the toasts
      boolean
      false
      
      Whether to pause toast when the user leaves the browser tab
      boolean
      true
      
      The placement of the toast
      | 'top-start'
      | 'top'
      | 'top-end'
      | 'bottom-start'
      | 'bottom'
      | 'bottom-end'
      "bottom-end"
      
      The duration for the toast to kept alive before it is removed. Useful for exit transitions.
      number
      200
      
      Type
      number
      Description
      The duration the toast will be visible, in milliseconds. By default, this is determined by the type of the toast.
      Type
      number
      Description
      The gap between the toasts
      Type
      number
      Description
      The maximum number of toasts. When the number of toasts exceeds this limit, the new toasts are queued.
      Type
      | string
      | Record<
      | 'bottom'
      | 'left'
      | 'right'
      | 'top',
      string
      >
      Description
      The offset from the safe environment edge of the viewport
      Type
      boolean
      Description
      Whether to overlap the toasts
      Type
      boolean
      Description
      Whether to pause toast when the user leaves the browser tab
      Type
      | 'top-start'
      | 'top'
      | 'top-end'
      | 'bottom-start'
      | 'bottom'
      | 'bottom-end'
      Description
      The placement of the toast
      Type
      number
      Description
      The duration for the toast to kept alive before it is removed. Useful for exit transitions.

      ToasterInstance

      This is the instance returned from the createToaster function.

      PropType
      The attributes of the toast store
      Create a new toast with the given options
        (
        data: ToastOptions<
        string | ReactElement
        >,
        ) => string
        Dismiss a toast by its ID. If no ID is provided, dismisses all toasts
          (
          id?: string,
          ) => void
          Get the total number of toasts
            () => number
            Get all currently visible toasts
              () => Partial<
              ToastApiProps<
              string | ReactElement
              >
              >[]
              Check if a toast with the given ID has been dismissed
                (
                id: string,
                ) => boolean
                Check if a toast with the given ID is currently visible
                  (
                  id: string,
                  ) => boolean
                  Pause a toast's auto-dismiss timer. If no ID is provided, pauses all toasts
                    (
                    id?: string,
                    ) => void
                    Create a toast that tracks a promise's state
                      (
                      promise:
                      | Promise<T>
                      | (() => Promise<T>),
                      options: ToastPromiseOptions<
                      string | ReactElement
                      >,
                      shared?: Omit<
                      ToastOptions<V>,
                      'type'
                      >,
                      ) => {
                      id: string
                      unwrap: () => Promise<T>
                      }
                      Remove a toast by its ID
                        (
                        id?: string,
                        ) => void
                        Resume a toast's auto-dismiss timer. If no ID is provided, resumes all toasts
                          (
                          id?: string,
                          ) => void
                          Subscribe to the toast store
                            (
                            subscriber: (
                            ...args: any[]
                            ) => void,
                            ) => VoidFunction
                            Update an existing toast with new properties
                              (
                              id: string,
                              data: Partial<
                              ToastApiProps<V>
                              >,
                              ) => string
                              Description
                              The attributes of the toast store
                              Type
                              (
                              data: ToastOptions<
                              string | ReactElement
                              >,
                              ) => string
                              Description
                              Create a new toast with the given options
                                Type
                                (
                                id?: string,
                                ) => void
                                Description
                                Dismiss a toast by its ID. If no ID is provided, dismisses all toasts
                                  Type
                                  () => number
                                  Description
                                  Get the total number of toasts
                                    Type
                                    () => Partial<
                                    ToastApiProps<
                                    string | ReactElement
                                    >
                                    >[]
                                    Description
                                    Get all currently visible toasts
                                      Type
                                      (
                                      id: string,
                                      ) => boolean
                                      Description
                                      Check if a toast with the given ID has been dismissed
                                        Type
                                        (
                                        id: string,
                                        ) => boolean
                                        Description
                                        Check if a toast with the given ID is currently visible
                                          Type
                                          (
                                          id?: string,
                                          ) => void
                                          Description
                                          Pause a toast's auto-dismiss timer. If no ID is provided, pauses all toasts
                                            Type
                                            (
                                            promise:
                                            | Promise<T>
                                            | (() => Promise<T>),
                                            options: ToastPromiseOptions<
                                            string | ReactElement
                                            >,
                                            shared?: Omit<
                                            ToastOptions<V>,
                                            'type'
                                            >,
                                            ) => {
                                            id: string
                                            unwrap: () => Promise<T>
                                            }
                                            Description
                                            Create a toast that tracks a promise's state
                                              Type
                                              (
                                              id?: string,
                                              ) => void
                                              Description
                                              Remove a toast by its ID
                                                Type
                                                (
                                                id?: string,
                                                ) => void
                                                Description
                                                Resume a toast's auto-dismiss timer. If no ID is provided, resumes all toasts
                                                  Type
                                                  (
                                                  subscriber: (
                                                  ...args: any[]
                                                  ) => void,
                                                  ) => VoidFunction
                                                  Description
                                                  Subscribe to the toast store
                                                    Type
                                                    (
                                                    id: string,
                                                    data: Partial<
                                                    ToastApiProps<V>
                                                    >,
                                                    ) => string
                                                    Description
                                                    Update an existing toast with new properties

                                                      <Toaster>

                                                      PropTypeDefault
                                                      The ToasterInstance instance.
                                                      FunctionRenderProp<ToastOptions>
                                                      The document's text/writing direction.
                                                      'ltr' | 'rtl'
                                                      'ltr'
                                                      
                                                      A root node to correctly resolve document in custom environments. i.e., Iframes, Electron.
                                                        () =>
                                                        | Node
                                                        | ShadowRoot
                                                        | Document
                                                        Allows you to replace the component's HTML element with a different tag or component. Learn more
                                                        | ReactElement
                                                        | ((
                                                        props: object,
                                                        ) => ReactElement)
                                                        Description
                                                        The ToasterInstance instance.
                                                        Type
                                                        FunctionRenderProp<ToastOptions>
                                                        Description
                                                        Render Prop that provides the ToastOptions.
                                                        Type
                                                        'ltr' | 'rtl'
                                                        Description
                                                        The document's text/writing direction.
                                                        Type
                                                        () =>
                                                        | Node
                                                        | ShadowRoot
                                                        | Document
                                                        Description
                                                        A root node to correctly resolve document in custom environments. i.e., Iframes, Electron.
                                                          Type
                                                          | ReactElement
                                                          | ((
                                                          props: object,
                                                          ) => ReactElement)
                                                          Description
                                                          Allows you to replace the component's HTML element with a different tag or component. Learn more

                                                          ToastPromiseOptions

                                                          These are the options passed to the toaster.promise function.

                                                          PropType
                                                          The options for the toast that displays while the Promise is pending.
                                                          Omit<
                                                          ToastOptions,
                                                          'type'
                                                          >
                                                          The function called when the Promise is rejected.
                                                              (
                                                              response: any,
                                                              ) => Omit<
                                                              ToastOptions<V>,
                                                              'type'
                                                              >
                                                              The function called after the Promise is resolved successfully or rejected.
                                                                  () => void | Promise<void>
                                                                  The function called when the Promise is resolved successfully.
                                                                      (
                                                                      response: any,
                                                                      ) => Omit<
                                                                      ToastOptions<V>,
                                                                      'type'
                                                                      >
                                                                      Type
                                                                      Omit<
                                                                      ToastOptions,
                                                                      'type'
                                                                      >
                                                                      Description
                                                                      The options for the toast that displays while the Promise is pending.
                                                                      Type
                                                                      (
                                                                      response: any,
                                                                      ) => Omit<
                                                                      ToastOptions<V>,
                                                                      'type'
                                                                      >
                                                                      Description
                                                                      The function called when the Promise is rejected.
                                                                          Type
                                                                          () => void | Promise<void>
                                                                          Description
                                                                          The function called after the Promise is resolved successfully or rejected.
                                                                              Type
                                                                              (
                                                                              response: any,
                                                                              ) => Omit<
                                                                              ToastOptions<V>,
                                                                              'type'
                                                                              >
                                                                              Description
                                                                              The function called when the Promise is resolved successfully.

                                                                                  ToastStatusChangeDetails

                                                                                  PropType
                                                                                  The reason for the status change
                                                                                  string
                                                                                  The render status of the toast
                                                                                  | 'visible'
                                                                                  | 'dismissing'
                                                                                  | 'unmounted'
                                                                                  Type
                                                                                  string
                                                                                  Description
                                                                                  The reason for the status change
                                                                                  Type
                                                                                  | 'visible'
                                                                                  | 'dismissing'
                                                                                  | 'unmounted'
                                                                                  Description
                                                                                  The render status of the toast