@react-md/core 1.0.0-next.0

package/dist/snackbar/ToastManager.js

@@ -0,0 +1,460 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { nanoid } from "nanoid";
+/**
+ * @remarks \@since 6.0.0
+ */ export const DEFAULT_TOAST_VISIBLE_TIME = 5000;
+var _queue = /*#__PURE__*/ new WeakMap(), _timers = /*#__PURE__*/ new WeakMap(), _listeners = /*#__PURE__*/ new WeakMap(), _emit = /*#__PURE__*/ new WeakMap(), _getToastIndex = /*#__PURE__*/ new WeakMap(), _getToast = /*#__PURE__*/ new WeakMap(), /**
+   * Starts the exit transition for the currently shown toast and adds the next
+   * toast into the queue. This requires a manual call to `this.#emit()`
+   * afterwards.
+   */ _addToastImmediately = /*#__PURE__*/ new WeakMap(), /**
+   * This calls `this.#emit()` if the toast was updated
+   */ _updateToast = /*#__PURE__*/ new WeakMap();
+/**
+ * @see {@link ToastManagerProvider}
+ *
+ * @remarks \@since 6.0.0
+ */ export class ToastManager {
+    constructor(){
+        _class_private_field_init(this, _queue, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _timers, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _listeners, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _emit, {
+            writable: true,
+            value: ()=>{
+                // shallow clone to ensure react updates
+                _class_private_field_set(this, _queue, [
+                    ..._class_private_field_get(this, _queue)
+                ]);
+                _class_private_field_get(this, _listeners).forEach((callback)=>{
+                    callback(_class_private_field_get(this, _queue));
+                });
+            }
+        });
+        _class_private_field_init(this, _getToastIndex, {
+            writable: true,
+            value: (toastId)=>{
+                if (!toastId) {
+                    return -1;
+                }
+                return _class_private_field_get(this, _queue).findIndex((toast)=>toast.toastId === toastId);
+            }
+        });
+        _class_private_field_init(this, _getToast, {
+            writable: true,
+            value: (toastId)=>{
+                return _class_private_field_get(this, _queue)[_class_private_field_get(this, _getToastIndex).call(this, toastId)];
+            }
+        });
+        _class_private_field_init(this, _addToastImmediately, {
+            writable: true,
+            value: (nextToast)=>{
+                const [current] = _class_private_field_get(this, _queue);
+                this.clearTimer(current.toastId);
+                _class_private_field_get(this, _queue)[0] = {
+                    ...current,
+                    visible: false
+                };
+                if (nextToast.priority === "immediate") {
+                    _class_private_field_get(this, _queue).splice(1, 0, nextToast, current);
+                } else {
+                    _class_private_field_get(this, _queue).splice(1, 0, nextToast);
+                }
+            }
+        });
+        _class_private_field_init(this, _updateToast, {
+            writable: true,
+            value: (toastIdOrIndex, patch)=>{
+                const index = typeof toastIdOrIndex === "number" ? toastIdOrIndex : _class_private_field_get(this, _getToastIndex).call(this, toastIdOrIndex);
+                if (index === -1) {
+                    return;
+                }
+                _class_private_field_get(this, _queue)[index] = {
+                    ..._class_private_field_get(this, _queue)[index],
+                    ...patch
+                };
+                _class_private_field_get(this, _emit).call(this);
+            }
+        });
+        /**
+   * This is just used to subscribe to changes in the {@link useToastQueue}.
+   *
+   * ```tsx
+   * useSyncExternalStore(
+   *   toastManager.subscribe,
+   *   toastManager.getQueue,
+   *   toastManager.getQueue,
+   * );
+   * ```
+   *
+   * @internal
+   */ _define_property(this, "subscribe", (callback)=>{
+            _class_private_field_get(this, _listeners).push(callback);
+            return ()=>{
+                _class_private_field_set(this, _listeners, _class_private_field_get(this, _listeners).filter((cb)=>cb !== callback));
+            };
+        });
+        /**
+   * @see {@link subscribe}
+   * @internal
+   */ _define_property(this, "getQueue", ()=>{
+            return _class_private_field_get(this, _queue);
+        });
+        /**
+   * Either adds the toast to the queue or updates an existing toast when using
+   * an existing `toastId`.
+   *
+   * @example
+   * Adding toasts
+   * ```tsx
+   * // create a toast when the user is offline that will not disappear
+   * addToast({ toastId: "offline", visibleTime: null });
+   *
+   * // add a new toast that displays `"Toast"` to the queue
+   * addToast({ children: "Toast!" });
+   *
+   * // add an online toast notification. since these three use the same toast
+   * // id, the hide timer will be reset each time
+   * addToast({ toastId: "online" });
+   * addToast({ toastId: "online" });
+   * addToast({ toastId: "online" });
+   *
+   * // add a server error toast to the queue where the second one will be
+   * // ignored
+   * addToast({
+   *   toastId: "ServerError",
+   *   theme: "error",
+   *   duplicates: "prevent",
+   * });
+   * addToast({
+   *   toastId: "ServerError",
+   *   theme: "error",
+   *   duplicates: "prevent",
+   * });
+   *
+   * // add a toast to the queue that has an action button that says "Goodbye"
+   * addToast({
+   *   children: "Hello, world!",
+   *   action: "Goodbye",
+   * });
+   *
+   * // add a toast to the queue that has an action button that says "Goodbye"
+   * // and a custom click handler
+   * addToast({
+   *   children: "Hello, world!",
+   *   action: {
+   *     onClick: () => {
+   *       logout();
+   *     },
+   *     children: "Goodbye",
+   *   },
+   * });
+   *
+   * // add a toast to the queue that renders a react component in the content,
+   * // a custom action button implementation (using `ToastActionButton`), and a
+   * // close button
+   * addToast({
+   *   children: <SomeCustomComponent />,
+   *   actionButton: <SomeCustomActionButton />,
+   *   closeButton: true,
+   * });
+   * ```
+   */ _define_property(this, "addToast", (toast)=>{
+            const { toastId = nanoid(), visibleTime = DEFAULT_TOAST_VISIBLE_TIME, role = visibleTime === null ? "alert" : undefined, priority = "normal", duplicates = "restart" } = toast;
+            const existingIndex = _class_private_field_get(this, _getToastIndex).call(this, toast.toastId);
+            if (existingIndex !== -1 && duplicates !== "allow") {
+                const existingToast = _class_private_field_get(this, _queue)[existingIndex];
+                // reorder/move the existing toast to be the next item in the queue by:
+                // - removing the toast from the queue
+                // - inserting it into the next position with the updates
+                if (priority === "next" && existingIndex > 1) {
+                    _class_private_field_get(this, _queue).splice(existingIndex, 1);
+                    _class_private_field_get(this, _queue).splice(1, 0, {
+                        ...existingToast,
+                        ...toast
+                    });
+                    _class_private_field_get(this, _emit).call(this);
+                    return;
+                }
+                // only need to reorder the queue if it is not being shown
+                if ((priority === "replace" || priority === "immediate") && existingIndex !== 0) {
+                    _class_private_field_get(this, _queue).splice(existingIndex, 1);
+                    _class_private_field_get(this, _addToastImmediately).call(this, {
+                        ...existingToast,
+                        ...toast
+                    });
+                    _class_private_field_get(this, _emit).call(this);
+                    return;
+                }
+                const timers = _class_private_field_get(this, _timers).get(toastId);
+                if (existingToast.visible && duplicates === "restart" && timers) {
+                    _class_private_field_get(this, _timers).set(toastId, {
+                        ...timers,
+                        elapsedTime: 0
+                    });
+                    this.startRemoveTimeout(toastId);
+                }
+                _class_private_field_get(this, _updateToast).call(this, existingIndex, toast);
+                return;
+            }
+            const nextToast = {
+                ...toast,
+                role,
+                paused: false,
+                visible: true,
+                toastId,
+                priority,
+                duplicates,
+                visibleTime
+            };
+            const queueSize = _class_private_field_get(this, _queue).length;
+            if (priority === "next" && queueSize > 1) {
+                _class_private_field_get(this, _queue).splice(1, 0, nextToast);
+            } else if ((priority === "replace" || priority === "immediate") && queueSize > 0) {
+                _class_private_field_get(this, _addToastImmediately).call(this, nextToast);
+            } else {
+                _class_private_field_get(this, _queue).push(nextToast);
+            }
+            _class_private_field_get(this, _emit).call(this);
+        });
+        /**
+   * Attempts to start the timeout for removing the toast when the `visibleTime`
+   * is not null for a toast.
+   *
+   * @param toastId - The specific toastId to update
+   */ _define_property(this, "startRemoveTimeout", (toastId)=>{
+            const toast = _class_private_field_get(this, _getToast).call(this, toastId);
+            if (!toast) {
+                return;
+            }
+            const { visibleTime } = toast;
+            if (visibleTime === null) {
+                // Must manually be closed
+                return;
+            }
+            const cached = _class_private_field_get(this, _timers).get(toastId);
+            const timers = cached && {
+                ...cached
+            } || {
+                inactive: false,
+                startTime: Date.now(),
+                elapsedTime: 0
+            };
+            window.clearTimeout(timers.exitTimeout);
+            let duration = visibleTime;
+            if (timers.elapsedTime) {
+                duration -= timers.elapsedTime;
+            }
+            timers.inactive = false;
+            timers.exitTimeout = window.setTimeout(()=>{
+                this.removeToast(toastId, true);
+            }, duration);
+            _class_private_field_get(this, _timers).set(toastId, timers);
+        });
+        /**
+   * Pauses the remove timeout for a specific toast normally with hover events
+   * or the browser becoming inactive.
+   *
+   * @param toastId - The specific toastId to pause
+   */ _define_property(this, "pauseRemoveTimeout", (toastId)=>{
+            const toast = _class_private_field_get(this, _getToast).call(this, toastId);
+            const cached = _class_private_field_get(this, _timers).get(toastId);
+            if (!toast || !cached || cached.inactive) {
+                return;
+            }
+            window.clearTimeout(cached.exitTimeout);
+            const timers = {
+                ...cached
+            };
+            timers.inactive = true;
+            timers.elapsedTime = Date.now() - timers.startTime + timers.elapsedTime;
+            _class_private_field_get(this, _timers).set(toastId, timers);
+            _class_private_field_get(this, _updateToast).call(this, toastId, {
+                paused: true
+            });
+        });
+        /**
+   * Resumes the current remove timeout if it was paused by
+   * {@link pauseRemoveTimeout}.
+   *
+   * @param toastId - The specific toastId to resume
+   */ _define_property(this, "resumeRemoveTimeout", (toastId)=>{
+            const toastIndex = _class_private_field_get(this, _getToastIndex).call(this, toastId);
+            const timers = _class_private_field_get(this, _timers).get(toastId);
+            if (toastIndex === -1 || !timers?.startTime) {
+                return;
+            }
+            _class_private_field_get(this, _updateToast).call(this, toastIndex, {
+                paused: false
+            });
+            this.startRemoveTimeout(toastId);
+        });
+        /**
+   * Removes a toast by id from the queue without any exit animation.
+   *
+   * @param toastId - The specific {@link QueuedToast.toastId}
+   * @param transition - Set this to `true` to remove the toast by the exit
+   * transition instead of immediately.
+   */ _define_property(this, "removeToast", (toastId, transition)=>{
+            const toastIndex = _class_private_field_get(this, _getToastIndex).call(this, toastId);
+            if (toastIndex === -1) {
+                return;
+            }
+            if (transition) {
+                this.clearTimer(toastId);
+                _class_private_field_get(this, _updateToast).call(this, toastIndex, {
+                    visible: false
+                });
+                return;
+            }
+            _class_private_field_get(this, _queue).splice(toastIndex, 1);
+            _class_private_field_get(this, _emit).call(this);
+        });
+        /**
+   * Clears any pending timers for the provided toast id. This should generally
+   * be used in the `useEffect` cleanup effect for any custom toast renderer
+   * implementations.
+   *
+   * @example
+   * ```tsx
+   * const { toastId } = toast;
+   * const toastManager = useToastManager();
+   *
+   * useEffect(() => {
+   *   return () => {
+   *     toastManager.clearTimer(toastId):
+   *   }
+   * }, [toastManager, toastId]);
+   * ```
+   */ _define_property(this, "clearTimer", (toastId)=>{
+            const timer = _class_private_field_get(this, _timers).get(toastId);
+            window.clearTimeout(timer?.exitTimeout);
+            _class_private_field_get(this, _timers).delete(toastId);
+        });
+        /**
+   * Removes first toast from the queue without any exit animation. You most
+   * likely want to use {@link removeToast} instead.
+   */ _define_property(this, "popToast", ()=>{
+            _class_private_field_get(this, _queue).pop();
+            _class_private_field_get(this, _emit).call(this);
+        });
+        /**
+   * Removes all toasts from the queue. There will be no exit animation.
+   *
+   * @param disableEmit - Set this to `true` to disable emitting the empty queue.
+   * Mostly used for tests.
+   */ _define_property(this, "clearToasts", (disableEmit = false)=>{
+            _class_private_field_set(this, _queue, []);
+            _class_private_field_get(this, _timers).forEach((meta)=>{
+                window.clearTimeout(meta.exitTimeout);
+            });
+            _class_private_field_get(this, _timers).clear();
+            if (!disableEmit) {
+                _class_private_field_get(this, _emit).call(this);
+            }
+        });
+        _class_private_field_set(this, _queue, []);
+        _class_private_field_set(this, _timers, new Map());
+        _class_private_field_set(this, _listeners, []);
+    // All of the class methods must be arrow functions to preserve the correct
+    // `this` value. If they aren't arrow functions, I'd have to wrap each call
+    // in an arrow function to work.
+    //
+    // i.e.
+    // useSyncExternalStore(
+    //   (cb) => manager.subscribe(cb),
+    //   () => manager.getQueue(),
+    //   () => manager.getQueue(),
+    // );
+    }
+}
+/**
+ * The default toast manager for react-md apps that will allow toasts to be
+ * added without setting up the {@link ToastManagerProvider}.
+ *
+ * @internal
+ * @remarks \@since 6.0.0
+ */ export const toastManager = new ToastManager();
+/**
+ * @see {@link ToastManager.addToast}
+ * @remarks \@since 6.0.0
+ */ export const addToast = (toast)=>toastManager.addToast(toast);
+/**
+ * @see {@link ToastManager.startRemoveTimeout}
+ * @remarks \@since 6.0.0
+ */ export const startRemoveToastTimeout = (toastId)=>toastManager.startRemoveTimeout(toastId);
+/**
+ * @see {@link ToastManager.popToast}
+ * @remarks \@since 6.0.0
+ */ export const popToast = ()=>toastManager.popToast();
+/**
+ * @see {@link ToastManager.removeToast}
+ * @remarks \@since 6.0.0
+ */ export const removeToast = (toastId, transition)=>toastManager.removeToast(toastId, transition);
+/**
+ * @see {@link ToastManager.clearToasts}
+ * @remarks \@since 6.0.0
+ */ export const clearToasts = ()=>toastManager.clearToasts();
+
+//# sourceMappingURL=ToastManager.js.map

package/dist/snackbar/ToastManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/snackbar/ToastManager.tsx"],"sourcesContent":["import { nanoid } from \"nanoid\";\nimport { type ConfigurableToastProps } from \"./Toast.js\";\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport const DEFAULT_TOAST_VISIBLE_TIME = 5000;\n\n/**\n * - `\"normal\"` - the toast will be added to the end of the queue\n * - `\"next\"` - the toast will be inserted next-in-line in the queue, waiting\n *   for the current visible toast to exit before being shown. If the toast does\n *   not support duplicates, the existing toast will be moved instead and merged\n *   with the toast.\n * - `\"replace\"` - if there is a currently visible toast, it will start the\n *   leave transition and display the newly added toast instead.\n * - `\"immediate\"` - the same behavior as `\"replace\"` except that if there was a\n *   currently visible toast, it will be shown once the newly added toast again.\n *\n * @remarks \\@since 6.0.0 Renamed from `MessagePriority` to `ToastPriority`\n */\nexport type ToastPriority = \"normal\" | \"next\" | \"replace\" | \"immediate\";\n\n/**\n * - `\"allow\"` - toasts with the same `toastId` can be added into the queue, but\n *   the leave timeout behavior might not work if multiple toasts can be shown\n *   at the same time.\n * - `\"restart\"` - (default) toasts that have the same `toastId` as a toast\n *   being shown will restart the exit timeout and update the toast with any\n *   differences in the toast. If the toast is not currently being shown, a new\n *   toast will not be added.\n * - `\"update\"` - toasts that have the same `toastId` will just update the toast\n *   with the latest content while maintaining any existing timeouts\n *\n * @remarks \\@since 6.0.0 Renamed from `DuplicateBehavior`\n */\nexport type ToastDuplicateBehavior = \"allow\" | \"restart\" | \"update\";\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport interface ToastMeta {\n  /**\n   * This will be `true` if the exit timeout has been paused either by hovering\n   * the toast or the page has become inactive through blur or minimizing.\n   */\n  paused: boolean;\n\n  /**\n   * This will be `true` when the toast should be visible and `false` during the\n   * exit animation.\n   */\n  visible: boolean;\n\n  /**\n   * The current toast's id which can be used with the:\n   * - {@link ToastManager.removeToast}\n   * - {@link ToastManager.startRemoveTimeout}\n   * - {@link ToastManager.pauseRemoveTimeout}\n   * - {@link ToastManager.resumeRemoveTimeout}\n   */\n  toastId: string;\n  priority: ToastPriority;\n  duplicates: ToastDuplicateBehavior;\n  visibleTime: number | null;\n}\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport interface CreateToastOptions extends ConfigurableToastProps {\n  /**\n   * @defaultValue `nanoid()`\n   */\n  toastId?: string;\n\n  /**\n   * @see {@link ToastDuplicateBehavior}\n   * @defaultValue `\"restart\"`\n   */\n  duplicates?: ToastDuplicateBehavior;\n\n  /**\n   * @see {@link ToastPriority}\n   * @defaultValue `\"normal\"`\n   */\n  priority?: ToastPriority;\n\n  /**\n   * Set this to `null` to prevent the toast from automatically hiding,\n   * otherwise set this to the number of milliseconds to remain visible.\n   *\n   * @see {@link DEFAULT_TOAST_VISIBLE_TIME}\n   * @defaultValue `DEFAULT_TOAST_VISIBLE_TIME`\n   */\n  visibleTime?: number | null;\n}\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport interface QueuedToast extends ConfigurableToastProps, ToastMeta {}\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport type ToastQueue = readonly Readonly<QueuedToast>[];\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport type ToastCallback = (queue: ToastQueue) => void;\n\n/**\n * @internal\n * @remarks \\@since 6.0.0\n */\nexport interface ToastVisibilityTimers {\n  inactive: boolean;\n  startTime: number;\n  elapsedTime: number;\n  exitTimeout?: number;\n}\n\n/**\n * @see {@link ToastManagerProvider}\n *\n * @remarks \\@since 6.0.0\n */\nexport class ToastManager {\n  #queue: QueuedToast[];\n  #timers: Map<string, ToastVisibilityTimers>;\n  #listeners: ToastCallback[];\n\n  constructor() {\n    this.#queue = [];\n    this.#timers = new Map();\n    this.#listeners = [];\n\n    // All of the class methods must be arrow functions to preserve the correct\n    // `this` value. If they aren't arrow functions, I'd have to wrap each call\n    // in an arrow function to work.\n    //\n    // i.e.\n    // useSyncExternalStore(\n    //   (cb) => manager.subscribe(cb),\n    //   () => manager.getQueue(),\n    //   () => manager.getQueue(),\n    // );\n  }\n\n  #emit = (): void => {\n    // shallow clone to ensure react updates\n    this.#queue = [...this.#queue];\n    this.#listeners.forEach((callback) => {\n      callback(this.#queue);\n    });\n  };\n\n  #getToastIndex = (toastId: string | undefined): number => {\n    if (!toastId) {\n      return -1;\n    }\n\n    return this.#queue.findIndex((toast) => toast.toastId === toastId);\n  };\n\n  #getToast = (toastId: string | undefined): QueuedToast | undefined => {\n    return this.#queue[this.#getToastIndex(toastId)];\n  };\n\n  /**\n   * Starts the exit transition for the currently shown toast and adds the next\n   * toast into the queue. This requires a manual call to `this.#emit()`\n   * afterwards.\n   */\n  #addToastImmediately = (nextToast: QueuedToast): void => {\n    const [current] = this.#queue;\n    this.clearTimer(current.toastId);\n    this.#queue[0] = {\n      ...current,\n      visible: false,\n    };\n    if (nextToast.priority === \"immediate\") {\n      this.#queue.splice(1, 0, nextToast, current);\n    } else {\n      this.#queue.splice(1, 0, nextToast);\n    }\n  };\n\n  /**\n   * This calls `this.#emit()` if the toast was updated\n   */\n  #updateToast = (\n    toastIdOrIndex: string | number,\n    patch: Partial<QueuedToast>\n  ): void => {\n    const index =\n      typeof toastIdOrIndex === \"number\"\n        ? toastIdOrIndex\n        : this.#getToastIndex(toastIdOrIndex);\n\n    if (index === -1) {\n      return;\n    }\n\n    this.#queue[index] = {\n      ...this.#queue[index],\n      ...patch,\n    };\n    this.#emit();\n  };\n\n  /**\n   * This is just used to subscribe to changes in the {@link useToastQueue}.\n   *\n   * ```tsx\n   * useSyncExternalStore(\n   *   toastManager.subscribe,\n   *   toastManager.getQueue,\n   *   toastManager.getQueue,\n   * );\n   * ```\n   *\n   * @internal\n   */\n  subscribe = (callback: ToastCallback): (() => void) => {\n    this.#listeners.push(callback);\n\n    return () => {\n      this.#listeners = this.#listeners.filter((cb) => cb !== callback);\n    };\n  };\n\n  /**\n   * @see {@link subscribe}\n   * @internal\n   */\n  getQueue = (): ToastQueue => {\n    return this.#queue;\n  };\n\n  /**\n   * Either adds the toast to the queue or updates an existing toast when using\n   * an existing `toastId`.\n   *\n   * @example\n   * Adding toasts\n   * ```tsx\n   * // create a toast when the user is offline that will not disappear\n   * addToast({ toastId: \"offline\", visibleTime: null });\n   *\n   * // add a new toast that displays `\"Toast\"` to the queue\n   * addToast({ children: \"Toast!\" });\n   *\n   * // add an online toast notification. since these three use the same toast\n   * // id, the hide timer will be reset each time\n   * addToast({ toastId: \"online\" });\n   * addToast({ toastId: \"online\" });\n   * addToast({ toastId: \"online\" });\n   *\n   * // add a server error toast to the queue where the second one will be\n   * // ignored\n   * addToast({\n   *   toastId: \"ServerError\",\n   *   theme: \"error\",\n   *   duplicates: \"prevent\",\n   * });\n   * addToast({\n   *   toastId: \"ServerError\",\n   *   theme: \"error\",\n   *   duplicates: \"prevent\",\n   * });\n   *\n   * // add a toast to the queue that has an action button that says \"Goodbye\"\n   * addToast({\n   *   children: \"Hello, world!\",\n   *   action: \"Goodbye\",\n   * });\n   *\n   * // add a toast to the queue that has an action button that says \"Goodbye\"\n   * // and a custom click handler\n   * addToast({\n   *   children: \"Hello, world!\",\n   *   action: {\n   *     onClick: () => {\n   *       logout();\n   *     },\n   *     children: \"Goodbye\",\n   *   },\n   * });\n   *\n   * // add a toast to the queue that renders a react component in the content,\n   * // a custom action button implementation (using `ToastActionButton`), and a\n   * // close button\n   * addToast({\n   *   children: <SomeCustomComponent />,\n   *   actionButton: <SomeCustomActionButton />,\n   *   closeButton: true,\n   * });\n   * ```\n   */\n  addToast = (toast: CreateToastOptions): void => {\n    const {\n      toastId = nanoid(),\n      visibleTime = DEFAULT_TOAST_VISIBLE_TIME,\n      role = visibleTime === null ? \"alert\" : undefined,\n      priority = \"normal\",\n      duplicates = \"restart\",\n    } = toast;\n\n    const existingIndex = this.#getToastIndex(toast.toastId);\n    if (existingIndex !== -1 && duplicates !== \"allow\") {\n      const existingToast = this.#queue[existingIndex];\n\n      // reorder/move the existing toast to be the next item in the queue by:\n      // - removing the toast from the queue\n      // - inserting it into the next position with the updates\n      if (priority === \"next\" && existingIndex > 1) {\n        this.#queue.splice(existingIndex, 1);\n        this.#queue.splice(1, 0, { ...existingToast, ...toast });\n        this.#emit();\n        return;\n      }\n\n      // only need to reorder the queue if it is not being shown\n      if (\n        (priority === \"replace\" || priority === \"immediate\") &&\n        existingIndex !== 0\n      ) {\n        this.#queue.splice(existingIndex, 1);\n        this.#addToastImmediately({\n          ...existingToast,\n          ...toast,\n        });\n        this.#emit();\n        return;\n      }\n\n      const timers = this.#timers.get(toastId);\n      if (existingToast.visible && duplicates === \"restart\" && timers) {\n        this.#timers.set(toastId, { ...timers, elapsedTime: 0 });\n        this.startRemoveTimeout(toastId);\n      }\n\n      this.#updateToast(existingIndex, toast);\n      return;\n    }\n\n    const nextToast: QueuedToast = {\n      ...toast,\n      role,\n      paused: false,\n      visible: true,\n      toastId,\n      priority,\n      duplicates,\n      visibleTime,\n    };\n\n    const queueSize = this.#queue.length;\n    if (priority === \"next\" && queueSize > 1) {\n      this.#queue.splice(1, 0, nextToast);\n    } else if (\n      (priority === \"replace\" || priority === \"immediate\") &&\n      queueSize > 0\n    ) {\n      this.#addToastImmediately(nextToast);\n    } else {\n      this.#queue.push(nextToast);\n    }\n\n    this.#emit();\n  };\n\n  /**\n   * Attempts to start the timeout for removing the toast when the `visibleTime`\n   * is not null for a toast.\n   *\n   * @param toastId - The specific toastId to update\n   */\n  startRemoveTimeout = (toastId: string): void => {\n    const toast = this.#getToast(toastId);\n    if (!toast) {\n      return;\n    }\n\n    const { visibleTime } = toast;\n    if (visibleTime === null) {\n      // Must manually be closed\n      return;\n    }\n\n    const cached = this.#timers.get(toastId);\n    const timers = (cached && { ...cached }) || {\n      inactive: false,\n      startTime: Date.now(),\n      elapsedTime: 0,\n    };\n    window.clearTimeout(timers.exitTimeout);\n\n    let duration = visibleTime;\n    if (timers.elapsedTime) {\n      duration -= timers.elapsedTime;\n    }\n\n    timers.inactive = false;\n    timers.exitTimeout = window.setTimeout(() => {\n      this.removeToast(toastId, true);\n    }, duration);\n    this.#timers.set(toastId, timers);\n  };\n\n  /**\n   * Pauses the remove timeout for a specific toast normally with hover events\n   * or the browser becoming inactive.\n   *\n   * @param toastId - The specific toastId to pause\n   */\n  pauseRemoveTimeout = (toastId: string): void => {\n    const toast = this.#getToast(toastId);\n    const cached = this.#timers.get(toastId);\n    if (!toast || !cached || cached.inactive) {\n      return;\n    }\n\n    window.clearTimeout(cached.exitTimeout);\n    const timers = { ...cached };\n    timers.inactive = true;\n    timers.elapsedTime = Date.now() - timers.startTime + timers.elapsedTime;\n    this.#timers.set(toastId, timers);\n    this.#updateToast(toastId, { paused: true });\n  };\n\n  /**\n   * Resumes the current remove timeout if it was paused by\n   * {@link pauseRemoveTimeout}.\n   *\n   * @param toastId - The specific toastId to resume\n   */\n  resumeRemoveTimeout = (toastId: string): void => {\n    const toastIndex = this.#getToastIndex(toastId);\n    const timers = this.#timers.get(toastId);\n    if (toastIndex === -1 || !timers?.startTime) {\n      return;\n    }\n\n    this.#updateToast(toastIndex, { paused: false });\n    this.startRemoveTimeout(toastId);\n  };\n\n  /**\n   * Removes a toast by id from the queue without any exit animation.\n   *\n   * @param toastId - The specific {@link QueuedToast.toastId}\n   * @param transition - Set this to `true` to remove the toast by the exit\n   * transition instead of immediately.\n   */\n  removeToast = (toastId: string, transition: boolean): void => {\n    const toastIndex = this.#getToastIndex(toastId);\n    if (toastIndex === -1) {\n      return;\n    }\n\n    if (transition) {\n      this.clearTimer(toastId);\n      this.#updateToast(toastIndex, { visible: false });\n      return;\n    }\n\n    this.#queue.splice(toastIndex, 1);\n    this.#emit();\n  };\n\n  /**\n   * Clears any pending timers for the provided toast id. This should generally\n   * be used in the `useEffect` cleanup effect for any custom toast renderer\n   * implementations.\n   *\n   * @example\n   * ```tsx\n   * const { toastId } = toast;\n   * const toastManager = useToastManager();\n   *\n   * useEffect(() => {\n   *   return () => {\n   *     toastManager.clearTimer(toastId):\n   *   }\n   * }, [toastManager, toastId]);\n   * ```\n   */\n  clearTimer = (toastId: string): void => {\n    const timer = this.#timers.get(toastId);\n    window.clearTimeout(timer?.exitTimeout);\n    this.#timers.delete(toastId);\n  };\n\n  /**\n   * Removes first toast from the queue without any exit animation. You most\n   * likely want to use {@link removeToast} instead.\n   */\n  popToast = (): void => {\n    this.#queue.pop();\n    this.#emit();\n  };\n\n  /**\n   * Removes all toasts from the queue. There will be no exit animation.\n   *\n   * @param disableEmit - Set this to `true` to disable emitting the empty queue.\n   * Mostly used for tests.\n   */\n  clearToasts = (disableEmit = false): void => {\n    this.#queue = [];\n    this.#timers.forEach((meta) => {\n      window.clearTimeout(meta.exitTimeout);\n    });\n    this.#timers.clear();\n    if (!disableEmit) {\n      this.#emit();\n    }\n  };\n}\n\n/**\n * The default toast manager for react-md apps that will allow toasts to be\n * added without setting up the {@link ToastManagerProvider}.\n *\n * @internal\n * @remarks \\@since 6.0.0\n */\nexport const toastManager = new ToastManager();\n\n/**\n * @see {@link ToastManager.addToast}\n * @remarks \\@since 6.0.0\n */\nexport const addToast: ToastManager[\"addToast\"] = (toast) =>\n  toastManager.addToast(toast);\n\n/**\n * @see {@link ToastManager.startRemoveTimeout}\n * @remarks \\@since 6.0.0\n */\nexport const startRemoveToastTimeout: ToastManager[\"startRemoveTimeout\"] = (\n  toastId\n) => toastManager.startRemoveTimeout(toastId);\n\n/**\n * @see {@link ToastManager.popToast}\n * @remarks \\@since 6.0.0\n */\nexport const popToast: ToastManager[\"popToast\"] = () => toastManager.popToast();\n\n/**\n * @see {@link ToastManager.removeToast}\n * @remarks \\@since 6.0.0\n */\nexport const removeToast: ToastManager[\"removeToast\"] = (toastId, transition) =>\n  toastManager.removeToast(toastId, transition);\n\n/**\n * @see {@link ToastManager.clearToasts}\n * @remarks \\@since 6.0.0\n */\nexport const clearToasts = (): void => toastManager.clearToasts();\n"],"names":["nanoid","DEFAULT_TOAST_VISIBLE_TIME","ToastManager","constructor","queue","listeners","forEach","callback","toastId","findIndex","toast","getToastIndex","nextToast","current","clearTimer","visible","priority","splice","toastIdOrIndex","patch","index","emit","subscribe","push","filter","cb","getQueue","addToast","visibleTime","role","undefined","duplicates","existingIndex","existingToast","addToastImmediately","timers","get","set","elapsedTime","startRemoveTimeout","updateToast","paused","queueSize","length","getToast","cached","inactive","startTime","Date","now","window","clearTimeout","exitTimeout","duration","setTimeout","removeToast","pauseRemoveTimeout","resumeRemoveTimeout","toastIndex","transition","timer","delete","popToast","pop","clearToasts","disableEmit","meta","clear","Map","toastManager","startRemoveToastTimeout"],"mappings":"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"}

package/dist/snackbar/ToastManagerProvider.d.ts

@@ -0,0 +1,53 @@
+import { type ReactElement, type ReactNode } from "react";
+import { type ToastManager, type ToastQueue } from "./ToastManager.js";
+/**
+ * This is mostly an internal hook to implement the toast functionality but can
+ * be used externally as well for custom toast behavior if the other hooks do
+ * not support your needs.
+ *
+ * @see {@link useAddToast}
+ * @see {@link useToastQueue}
+ * @see {@link useRemoveToast}
+ *
+ * @returns The current `ToastManager` set in the `ToastManagerProvider`.
+ * Defaults to {@link toastManager} if there are no parent providers.
+ * @remarks \@since 6.0.0
+ */
+export declare function useToastManager(): ToastManager;
+/**
+ * @see {@link ToastManager.addToast}
+ * @remarks \@since 6.0.0
+ */
+export declare function useAddToast(): ToastManager["addToast"];
+/**
+ * @see {@link ToastManager.removeToast}
+ * @remarks \@since 6.0.0
+ */
+export declare function useRemoveToast(): ToastManager["removeToast"];
+/**
+ * @param limit - the total number of toasts that can be visible at once.
+ * @remarks \@since 6.0.0
+ */
+export declare function useToastQueue(limit?: number): ToastQueue;
+/**
+ * @remarks \@since 6.0.0
+ */
+export interface ToastManagerProviderProps {
+    children: ReactNode;
+    /**
+     * @defaultValue `toastManager`
+     */
+    manager?: ToastManager;
+}
+/**
+ * **Client Component**
+ *
+ * This component can be used to implement separate instances of toasts if
+ * required in your app. This probably shouldn't be required for most apps with
+ * the default {@link addToast}, {@link removeToast}, and {@link clearToasts}
+ * implementation.
+ *
+ * @see {@link ToastManager} for example usage.
+ * @remarks \@since 6.0.0
+ */
+export declare function ToastManagerProvider(props: ToastManagerProviderProps): ReactElement;

package/dist/snackbar/ToastManagerProvider.js

@@ -0,0 +1,69 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo, useSyncExternalStore } from "react";
+import { toastManager } from "./ToastManager.js";
+const context = /*#__PURE__*/ createContext(toastManager);
+context.displayName = "ToastManager";
+const { Provider } = context;
+/**
+ * This is mostly an internal hook to implement the toast functionality but can
+ * be used externally as well for custom toast behavior if the other hooks do
+ * not support your needs.
+ *
+ * @see {@link useAddToast}
+ * @see {@link useToastQueue}
+ * @see {@link useRemoveToast}
+ *
+ * @returns The current `ToastManager` set in the `ToastManagerProvider`.
+ * Defaults to {@link toastManager} if there are no parent providers.
+ * @remarks \@since 6.0.0
+ */ export function useToastManager() {
+    return useContext(context);
+}
+/**
+ * @see {@link ToastManager.addToast}
+ * @remarks \@since 6.0.0
+ */ export function useAddToast() {
+    return useToastManager().addToast;
+}
+/**
+ * @see {@link ToastManager.removeToast}
+ * @remarks \@since 6.0.0
+ */ export function useRemoveToast() {
+    return useToastManager().removeToast;
+}
+/**
+ * @param limit - the total number of toasts that can be visible at once.
+ * @remarks \@since 6.0.0
+ */ export function useToastQueue(limit) {
+    const toastManager = useToastManager();
+    const queue = useSyncExternalStore(toastManager.subscribe, toastManager.getQueue, toastManager.getQueue);
+    return useMemo(()=>{
+        if (!limit) {
+            return queue;
+        }
+        return queue.slice(0, limit);
+    }, [
+        limit,
+        queue
+    ]);
+}
+/**
+ * **Client Component**
+ *
+ * This component can be used to implement separate instances of toasts if
+ * required in your app. This probably shouldn't be required for most apps with
+ * the default {@link addToast}, {@link removeToast}, and {@link clearToasts}
+ * implementation.
+ *
+ * @see {@link ToastManager} for example usage.
+ * @remarks \@since 6.0.0
+ */ export function ToastManagerProvider(props) {
+    const { children, manager = toastManager } = props;
+    return /*#__PURE__*/ _jsx(Provider, {
+        value: manager,
+        children: children
+    });
+}
+
+//# sourceMappingURL=ToastManagerProvider.js.map

package/dist/snackbar/ToastManagerProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/snackbar/ToastManagerProvider.tsx"],"sourcesContent":["\"use client\";\n\nimport {\n  createContext,\n  useContext,\n  useMemo,\n  useSyncExternalStore,\n  type ReactElement,\n  type ReactNode,\n} from \"react\";\nimport {\n  toastManager,\n  type ToastManager,\n  type ToastQueue,\n} from \"./ToastManager.js\";\n\nconst context = createContext(toastManager);\ncontext.displayName = \"ToastManager\";\nconst { Provider } = context;\n\n/**\n * This is mostly an internal hook to implement the toast functionality but can\n * be used externally as well for custom toast behavior if the other hooks do\n * not support your needs.\n *\n * @see {@link useAddToast}\n * @see {@link useToastQueue}\n * @see {@link useRemoveToast}\n *\n * @returns The current `ToastManager` set in the `ToastManagerProvider`.\n * Defaults to {@link toastManager} if there are no parent providers.\n * @remarks \\@since 6.0.0\n */\nexport function useToastManager(): ToastManager {\n  return useContext(context);\n}\n\n/**\n * @see {@link ToastManager.addToast}\n * @remarks \\@since 6.0.0\n */\nexport function useAddToast(): ToastManager[\"addToast\"] {\n  return useToastManager().addToast;\n}\n\n/**\n * @see {@link ToastManager.removeToast}\n * @remarks \\@since 6.0.0\n */\nexport function useRemoveToast(): ToastManager[\"removeToast\"] {\n  return useToastManager().removeToast;\n}\n\n/**\n * @param limit - the total number of toasts that can be visible at once.\n * @remarks \\@since 6.0.0\n */\nexport function useToastQueue(limit?: number): ToastQueue {\n  const toastManager = useToastManager();\n\n  const queue = useSyncExternalStore(\n    toastManager.subscribe,\n    toastManager.getQueue,\n    toastManager.getQueue\n  );\n\n  return useMemo(() => {\n    if (!limit) {\n      return queue;\n    }\n\n    return queue.slice(0, limit);\n  }, [limit, queue]);\n}\n\n/**\n * @remarks \\@since 6.0.0\n */\nexport interface ToastManagerProviderProps {\n  children: ReactNode;\n\n  /**\n   * @defaultValue `toastManager`\n   */\n  manager?: ToastManager;\n}\n\n/**\n * **Client Component**\n *\n * This component can be used to implement separate instances of toasts if\n * required in your app. This probably shouldn't be required for most apps with\n * the default {@link addToast}, {@link removeToast}, and {@link clearToasts}\n * implementation.\n *\n * @see {@link ToastManager} for example usage.\n * @remarks \\@since 6.0.0\n */\nexport function ToastManagerProvider(\n  props: ToastManagerProviderProps\n): ReactElement {\n  const { children, manager = toastManager } = props;\n\n  return <Provider value={manager}>{children}</Provider>;\n}\n"],"names":["createContext","useContext","useMemo","useSyncExternalStore","toastManager","context","displayName","Provider","useToastManager","useAddToast","addToast","useRemoveToast","removeToast","useToastQueue","limit","queue","subscribe","getQueue","slice","ToastManagerProvider","props","children","manager","value"],"mappings":"AAAA;;AAEA,SACEA,aAAa,EACbC,UAAU,EACVC,OAAO,EACPC,oBAAoB,QAGf,QAAQ;AACf,SACEC,YAAY,QAGP,oBAAoB;AAE3B,MAAMC,wBAAUL,cAAcI;AAC9BC,QAAQC,WAAW,GAAG;AACtB,MAAM,EAAEC,QAAQ,EAAE,GAAGF;AAErB;;;;;;;;;;;;CAYC,GACD,OAAO,SAASG;IACd,OAAOP,WAAWI;AACpB;AAEA;;;CAGC,GACD,OAAO,SAASI;IACd,OAAOD,kBAAkBE,QAAQ;AACnC;AAEA;;;CAGC,GACD,OAAO,SAASC;IACd,OAAOH,kBAAkBI,WAAW;AACtC;AAEA;;;CAGC,GACD,OAAO,SAASC,cAAcC,KAAc;IAC1C,MAAMV,eAAeI;IAErB,MAAMO,QAAQZ,qBACZC,aAAaY,SAAS,EACtBZ,aAAaa,QAAQ,EACrBb,aAAaa,QAAQ;IAGvB,OAAOf,QAAQ;QACb,IAAI,CAACY,OAAO;YACV,OAAOC;QACT;QAEA,OAAOA,MAAMG,KAAK,CAAC,GAAGJ;IACxB,GAAG;QAACA;QAAOC;KAAM;AACnB;AAcA;;;;;;;;;;CAUC,GACD,OAAO,SAASI,qBACdC,KAAgC;IAEhC,MAAM,EAAEC,QAAQ,EAAEC,UAAUlB,YAAY,EAAE,GAAGgB;IAE7C,qBAAO,KAACb;QAASgB,OAAOD;kBAAUD;;AACpC"}