toastflow-core 0.0.1

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "toastflow-core",
+  "version": "0.0.1",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "vitest"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.13"
+  },
+  "dependencies": {
+    "uuid": "^13.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./store";

package/src/store.ts

@@ -0,0 +1,694 @@
+import type {
+  ToastConfig,
+  ToastContext,
+  ToastEvent,
+  ToastId,
+  ToastInstance,
+  ToastLoadingConfig,
+  ToastLoadingInput,
+  ToastLoadingResult,
+  ToastOptions,
+  ToastOrder,
+  ToastShowInput,
+  ToastState,
+  ToastStore,
+  ToastType,
+  ToastUpdateInput,
+} from "./types";
+import { v4 as uuidv4 } from "uuid";
+
+type Listener = (state: ToastState) => void;
+type EventListener = (event: ToastEvent) => void;
+type TimeoutHandle = ReturnType<typeof setTimeout>;
+
+interface TimerState {
+  timeout: TimeoutHandle | null;
+  startTime: number;
+  remaining: number;
+  paused: boolean;
+}
+
+const defaultCreatedAtFormatter = function (createdAt: number): string {
+  try {
+    return new Date(createdAt).toLocaleTimeString([], {
+      hour: "2-digit",
+      minute: "2-digit",
+    });
+  } catch (error) {
+    return new Date(createdAt).toISOString();
+  }
+};
+
+const defaults: ToastConfig = {
+  offset: "16px",
+  gap: "8px",
+  zIndex: 9999,
+  width: "350px",
+  duration: 5000,
+  maxVisible: 5,
+  position: "top-right",
+  preventDuplicates: false,
+  order: "newest",
+  progressBar: true,
+  pauseOnHover: true,
+  pauseStrategy: "resume",
+  animation: {
+    name: "Toastflow__animation",
+    bump: "Toastflow__animation-bump",
+    clearAll: "Toastflow__animation-clearAll",
+    update: "Toastflow__animation-update",
+  },
+  closeButton: true,
+  closeOnClick: false,
+  supportHtml: false,
+  showCreatedAt: false,
+  createdAtFormatter: defaultCreatedAtFormatter,
+};
+
+const HIDE_ANIMATION_DURATION = 50;
+
+export function createToastStore(
+  globalConfig: Partial<ToastConfig> = {},
+): ToastStore {
+  let state: ToastState = { toasts: [] };
+  const listeners = new Set<Listener>();
+  const eventListeners = new Set<EventListener>();
+  const timers = new Map<ToastId, TimerState>();
+  const promiseRuns = new Map<ToastId, symbol>();
+
+  const resolvedGlobalConfig: ToastConfig = getConfig();
+
+  function notify() {
+    for (const listener of listeners) {
+      listener(state);
+    }
+  }
+
+  function emitEvent(event: ToastEvent) {
+    for (const listener of eventListeners) {
+      listener(event);
+    }
+  }
+
+  function getState(): ToastState {
+    return state;
+  }
+
+  function subscribe(listener: Listener): () => void {
+    listeners.add(listener);
+    listener(state);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+
+  function subscribeEvents(listener: EventListener): () => void {
+    eventListeners.add(listener);
+    return () => {
+      eventListeners.delete(listener);
+    };
+  }
+
+  function show(options: ToastShowInput): ToastId {
+    assertShowInput(options, "show");
+
+    const toast = resolveConfig(resolvedGlobalConfig, options);
+
+    if (toast.preventDuplicates) {
+      const duplicate = state.toasts.find(function (t) {
+        return (
+          t.position === toast.position &&
+          t.type === toast.type &&
+          t.title === toast.title &&
+          t.description === toast.description &&
+          t.phase !== "leaving" &&
+          t.phase !== "clear-all"
+        );
+      });
+
+      if (duplicate) {
+        const updated: ToastInstance = {
+          ...duplicate,
+          ...toast,
+          id: duplicate.id,
+          createdAt: duplicate.createdAt,
+        };
+
+        clearAutoDismiss(duplicate.id);
+        scheduleAutoDismiss(updated);
+
+        state = {
+          toasts: state.toasts.map(function (t) {
+            return t.id === updated.id ? updated : t;
+          }),
+        };
+
+        emitEvent({ id: updated.id, kind: "duplicate" });
+        notify();
+
+        return duplicate.id;
+      }
+    }
+
+    const id = uuidv4();
+    const createdAt = Date.now();
+
+    const toastInstance: ToastInstance = {
+      ...toast,
+      id,
+      createdAt,
+      phase: "enter",
+    };
+
+    const samePos = state.toasts.filter(function (t) {
+      return (
+        t.position === toastInstance.position &&
+        t.phase !== "leaving" &&
+        t.phase !== "clear-all"
+      );
+    });
+
+    if (
+      toastInstance.maxVisible > 0 &&
+      samePos.length >= toastInstance.maxVisible
+    ) {
+      const toEvict = pickOverflowToast(samePos, toastInstance.order);
+      if (toEvict) {
+        dismiss(toEvict.id);
+      }
+    }
+
+    state = {
+      toasts: insertToast(state.toasts, toastInstance),
+    };
+
+    if (toastInstance.onMount) {
+      toastInstance.onMount({
+        id,
+        position: toastInstance.position,
+        type: toastInstance.type,
+        title: toastInstance.title,
+        description: toastInstance.description,
+        createdAt: toastInstance.createdAt,
+      });
+    }
+
+    scheduleAutoDismiss(toastInstance);
+    notify();
+
+    return id;
+  }
+
+  function loading<T>(
+    input: ToastLoadingInput<T>,
+    config: ToastLoadingConfig<T>,
+  ): ToastLoadingResult<T> {
+    const loadingOptions: ToastShowInput = {
+      ...config.loading,
+      type: "loading",
+      duration: Infinity,
+      progressBar: false,
+    };
+
+    assertShowInput(loadingOptions, "loading.loading");
+
+    const runToken = Symbol("toastflow-loading-run");
+    const toastId = show(loadingOptions);
+    promiseRuns.set(toastId, runToken);
+
+    function successOptions(value: T): ToastShowInput {
+      const resolved =
+        typeof config.success === "function"
+          ? config.success(value)
+          : config.success;
+
+      assertContentFields(resolved, "loading.success");
+
+      return {
+        ...resolvedGlobalConfig,
+        ...resolved,
+        type: "success",
+      };
+    }
+
+    function errorOptions(error: unknown): ToastShowInput {
+      const resolved =
+        typeof config.error === "function" ? config.error(error) : config.error;
+
+      assertContentFields(resolved, "loading.error");
+
+      return {
+        ...resolvedGlobalConfig,
+        ...resolved,
+        type: "error",
+      };
+    }
+
+    function applyIfActive(options: ToastShowInput) {
+      if (promiseRuns.get(toastId) !== runToken) {
+        return;
+      }
+      promiseRuns.delete(toastId);
+      update(toastId, options);
+    }
+
+    function handleSuccess(value: T): T {
+      applyIfActive(successOptions(value));
+      return value;
+    }
+
+    function handleError(error: unknown): never {
+      applyIfActive(errorOptions(error));
+      throw error;
+    }
+
+    let task: Promise<T>;
+    try {
+      task = typeof input === "function" ? input() : input;
+    } catch (error) {
+      applyIfActive(errorOptions(error));
+      const rejected = Promise.reject(error) as ToastLoadingResult<T>;
+      rejected.toastId = toastId;
+      return rejected;
+    }
+
+    const result = task.then(
+      handleSuccess,
+      handleError,
+    ) as ToastLoadingResult<T>;
+    result.toastId = toastId;
+    return result;
+  }
+
+  function update(id: ToastId, options: ToastUpdateInput): void {
+    const existing = state.toasts.find((t) => t.id === id);
+    if (!existing) {
+      return;
+    }
+
+    assertUpdateInput(options);
+
+    if (options.type) {
+      assertToastType(options.type, "update");
+    }
+
+    const merged: ToastOptions = {
+      ...existing,
+      ...options,
+    };
+
+    const resolved = resolveConfig(resolvedGlobalConfig, merged);
+
+    const updated: ToastInstance = {
+      ...existing,
+      ...resolved,
+      id: existing.id,
+      createdAt: existing.createdAt,
+    };
+
+    clearAutoDismiss(id);
+    scheduleAutoDismiss(updated);
+
+    state = {
+      toasts: state.toasts.map((t) => (t.id === id ? updated : t)),
+    };
+
+    emitEvent({ id, kind: "timer-reset" });
+    emitEvent({ id, kind: "update" });
+    notify();
+  }
+
+  function dismiss(id: ToastId): void {
+    const toast = state.toasts.find((t) => t.id === id);
+    if (!toast) {
+      clearAutoDismiss(id);
+      return;
+    }
+
+    clearAutoDismiss(id);
+    promiseRuns.delete(id);
+
+    const context: ToastContext = {
+      id,
+      position: toast.position,
+      type: toast.type,
+      title: toast.title,
+      description: toast.description,
+      createdAt: toast.createdAt,
+    };
+
+    if (toast.onClose) {
+      toast.onClose(context);
+    }
+
+    state = {
+      toasts: state.toasts.map(function (t) {
+        if (t.id !== id) {
+          return t;
+        }
+        return {
+          ...t,
+          phase: "leaving",
+        };
+      }),
+    };
+
+    notify();
+
+    setTimeout(function () {
+      const still = state.toasts.find((t) => t.id === id);
+      if (!still) {
+        return;
+      }
+
+      state = {
+        toasts: state.toasts.filter((t) => t.id !== id),
+      };
+
+      if (toast.onUnmount) {
+        toast.onUnmount(context);
+      }
+
+      notify();
+    }, HIDE_ANIMATION_DURATION);
+  }
+
+  function dismissAll(): void {
+    if (!state.toasts.length) {
+      return;
+    }
+
+    const current = state.toasts;
+
+    for (const toast of current) {
+      clearAutoDismiss(toast.id);
+      promiseRuns.delete(toast.id);
+
+      const context: ToastContext = {
+        id: toast.id,
+        position: toast.position,
+        type: toast.type,
+        title: toast.title,
+        description: toast.description,
+        createdAt: toast.createdAt,
+      };
+
+      if (toast.onClose) {
+        toast.onClose(context);
+      }
+    }
+
+    state = {
+      toasts: state.toasts.map(function (t) {
+        return {
+          ...t,
+          phase: "clear-all",
+        };
+      }),
+    };
+
+    notify();
+
+    setTimeout(function () {
+      for (const toast of current) {
+        const context: ToastContext = {
+          id: toast.id,
+          position: toast.position,
+          type: toast.type,
+          title: toast.title,
+          description: toast.description,
+          createdAt: toast.createdAt,
+        };
+
+        if (toast.onUnmount) {
+          toast.onUnmount(context);
+        }
+      }
+
+      state = { toasts: [] };
+      notify();
+    }, HIDE_ANIMATION_DURATION);
+  }
+
+  function scheduleAutoDismiss(toastInstance: ToastInstance) {
+    if (
+      !Number.isFinite(toastInstance.duration) ||
+      toastInstance.duration <= 0
+    ) {
+      timers.delete(toastInstance.id);
+      return;
+    }
+
+    const now = Date.now();
+    const duration = toastInstance.duration;
+
+    const handle: TimeoutHandle = setTimeout(() => {
+      dismiss(toastInstance.id);
+    }, duration);
+
+    timers.set(toastInstance.id, {
+      timeout: handle,
+      startTime: now,
+      remaining: duration,
+      paused: false,
+    });
+  }
+
+  function clearAutoDismiss(id: ToastId) {
+    const timer = timers.get(id);
+    if (timer && timer.timeout) {
+      clearTimeout(timer.timeout);
+    }
+    timers.delete(id);
+  }
+
+  function pause(id: ToastId): void {
+    const timer = timers.get(id);
+    if (!timer || timer.paused) {
+      return;
+    }
+
+    const now = Date.now();
+    const elapsed = now - timer.startTime;
+    const remaining = Math.max(timer.remaining - elapsed, 0);
+
+    if (timer.timeout) {
+      clearTimeout(timer.timeout);
+    }
+
+    timers.set(id, {
+      timeout: null,
+      startTime: now,
+      remaining,
+      paused: true,
+    });
+  }
+
+  function resume(id: ToastId): void {
+    const timer = timers.get(id);
+    const toastInstance = state.toasts.find((t) => t.id === id);
+
+    if (!toastInstance) {
+      timers.delete(id);
+      return;
+    }
+
+    if (
+      toastInstance.duration === 0 ||
+      !Number.isFinite(toastInstance.duration)
+    ) {
+      timers.delete(id);
+      return;
+    }
+
+    const strategy = toastInstance.pauseStrategy;
+
+    let remaining: number;
+
+    if (!timer || !timer.paused) {
+      remaining = toastInstance.duration;
+      if (strategy === "reset") {
+        emitEvent({ id, kind: "timer-reset" });
+      }
+    } else {
+      if (strategy === "reset") {
+        remaining = toastInstance.duration;
+        emitEvent({ id, kind: "timer-reset" });
+      } else {
+        remaining = timer.remaining;
+      }
+    }
+
+    if (remaining <= 0) {
+      dismiss(id);
+      return;
+    }
+
+    const now = Date.now();
+    const handle: TimeoutHandle = setTimeout(() => {
+      dismiss(id);
+    }, remaining);
+
+    timers.set(id, {
+      timeout: handle,
+      startTime: now,
+      remaining,
+      paused: false,
+    });
+  }
+
+  function getConfig(): ToastConfig {
+    return {
+      ...defaults,
+      ...globalConfig,
+      animation: {
+        ...defaults.animation,
+        ...(globalConfig.animation ?? {}),
+      },
+    };
+  }
+
+  return {
+    getState,
+    subscribe,
+    subscribeEvents,
+    show,
+    loading,
+    update,
+    dismiss,
+    dismissAll,
+    pause,
+    resume,
+    getConfig,
+  };
+}
+
+// ------------- helpers -------------
+
+const VALID_TYPES = new Set<ToastType>([
+  "loading",
+  "default",
+  "success",
+  "error",
+  "info",
+  "warning",
+]);
+
+function assertToastType(type: ToastType, caller: string) {
+  if (!VALID_TYPES.has(type)) {
+    throw new Error(`[toastflow-core] ${caller} requires a valid toast type.`);
+  }
+}
+
+function assertContentFields(
+  options: { title?: unknown; description?: unknown },
+  caller: string,
+): asserts options is { title?: string; description?: string } {
+  const hasTitle = isNonEmptyString(options.title);
+  const hasDescription = isNonEmptyString(options.description);
+
+  if (!hasTitle && !hasDescription) {
+    throw new Error(
+      `[toastflow-core] ${caller} requires a non-empty title or description.`,
+    );
+  }
+}
+
+function assertShowInput(options: ToastShowInput, caller: string) {
+  assertToastType(options.type, caller);
+  assertContentFields(options, caller);
+}
+
+function assertUpdateInput(options: ToastUpdateInput) {
+  assertContentFields(options, "update");
+}
+
+function isNonEmptyString(value: unknown): boolean {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function resolveConfig(
+  base: ToastConfig,
+  overrides: ToastOptions | ToastShowInput | ToastUpdateInput,
+): ToastOptions {
+  const {
+    type,
+    title,
+    description,
+    animation: animationOverride,
+    ...restOverrides
+  } = overrides as Partial<ToastOptions>;
+
+  const animation = {
+    ...base.animation,
+    ...(animationOverride ?? {}),
+  };
+
+  return {
+    ...base,
+    ...restOverrides,
+    animation,
+    type: type ?? "default",
+    title: title ?? "",
+    description: description ?? "",
+  };
+}
+
+function insertToast(
+  existing: ToastInstance[],
+  next: ToastInstance,
+): ToastInstance[] {
+  if (next.duration === 0 || !Number.isFinite(next.duration)) {
+    next.progressBar = false;
+  }
+
+  const position = next.position;
+  const order = next.order;
+
+  const others = existing.filter((t) => t.position !== position);
+  const samePos = existing.filter((t) => t.position === position);
+
+  const isTop = position.startsWith("top-");
+
+  if (order === "newest") {
+    if (isTop) {
+      return [...others, next, ...samePos];
+    } else {
+      return [...others, ...samePos, next];
+    }
+  }
+
+  if (isTop) {
+    return [...others, ...samePos, next];
+  } else {
+    return [...others, next, ...samePos];
+  }
+}
+
+function pickOverflowToast(
+  samePos: ToastInstance[],
+  order: ToastOrder,
+): ToastInstance | null {
+  if (!samePos.length) {
+    return null;
+  }
+
+  if (order === "newest") {
+    let oldest = samePos[0];
+    for (const t of samePos) {
+      if (t.createdAt < oldest.createdAt) {
+        oldest = t;
+      }
+    }
+    return oldest;
+  }
+
+  let newest = samePos[0];
+  for (const t of samePos) {
+    if (t.createdAt > newest.createdAt) {
+      newest = t;
+    }
+  }
+
+  return newest;
+}

package/src/types.ts

@@ -0,0 +1,315 @@
+/**
+ * Unique identifier assigned to each toast instance.
+ */
+export type ToastId = string;
+
+/**
+ * Supported viewport anchors where toasts can stack.
+ */
+export type ToastPosition =
+  | "top-left"
+  | "top-center"
+  | "top-right"
+  | "bottom-left"
+  | "bottom-center"
+  | "bottom-right";
+/**
+ * Order to display and evict toasts in a stack.
+ */
+export type ToastOrder = "newest" | "oldest";
+/**
+ * Determines how the timer behaves after an interaction pause.
+ */
+export type PauseStrategy = "resume" | "reset";
+/**
+ * Semantic type that controls the toast's appearance.
+ */
+export type ToastType =
+  | "loading"
+  | "default"
+  | "success"
+  | "error"
+  | "info"
+  | "warning";
+/**
+ * Internal lifecycle markers used for animations and cleanup.
+ */
+export type ToastPhase = "enter" | "leaving" | "clear-all";
+/**
+ * Event kinds emitted to event subscribers.
+ */
+export type ToastEventKind = "duplicate" | "timer-reset" | "update";
+
+/**
+ * Payload emitted whenever the store dispatches a toast event.
+ */
+export interface ToastEvent {
+  id: ToastId;
+  kind: ToastEventKind;
+}
+
+/**
+ * Async work passed to the loading helper.
+ */
+export type ToastLoadingInput<T> = Promise<T> | (() => Promise<T>);
+
+/**
+ * Text and rendering options for the loading helper phases.
+ */
+export interface ToastLoadingConfig<T> {
+  loading: ToastContentInput;
+  success: ToastLoadingRender<T>;
+  error: ToastLoadingRender<unknown>;
+}
+
+/**
+ * CSS class names used to animate toasts.
+ */
+export interface ToastAnimation {
+  name: string;
+  bump: string;
+  clearAll: string;
+  update: string;
+}
+
+/**
+ * Minimal context shared with lifecycle and click callbacks.
+ */
+export interface ToastContext {
+  id: ToastId;
+  position: ToastPosition;
+  type: ToastType;
+  title: string;
+  description: string;
+  createdAt: number;
+}
+
+/**
+ * Global configuration that shapes how toasts look and behave.
+ */
+export interface ToastConfig {
+  /**
+   * Distance from the viewport edge where toasts start.
+   */
+  offset: string;
+  /**
+   * Gap between toasts stacked at the same position.
+   */
+  gap: string;
+  /**
+   * z-index applied to the toast container.
+   */
+  zIndex: number;
+  /**
+   * Fixed width applied to each toast.
+   */
+  width: string;
+
+  /**
+   * Time in milliseconds before a toast auto-dismisses.
+   * Use Infinity or 0 to keep it visible until manually dismissed.
+   */
+  duration: number;
+  /**
+   * Maximum number of visible toasts per position; extra items are evicted.
+   */
+  maxVisible: number;
+  /**
+   * Default stack position used when none is provided.
+   */
+  position: ToastPosition;
+
+  /**
+   * When true, skip showing identical toasts that are still visible.
+   */
+  preventDuplicates: boolean;
+  /**
+   * Controls whether new toasts appear before or after older ones.
+   */
+  order: ToastOrder;
+
+  /**
+   * When enabled, render a progress bar for finite durations.
+   */
+  progressBar: boolean;
+  /**
+   * Pause the timer while the toast is hovered.
+   */
+  pauseOnHover: boolean;
+  /**
+   * Whether resuming should continue the remaining time or restart it.
+   */
+  pauseStrategy: PauseStrategy;
+
+  /**
+   * CSS animation class overrides for various toast transitions.
+   */
+  animation: Partial<ToastAnimation>;
+
+  /**
+   * Show a close button inside each toast.
+   */
+  closeButton: boolean;
+  /**
+   * Allow closing a toast by clicking anywhere on it.
+   */
+  closeOnClick: boolean;
+
+  /**
+   * When true, title/description may contain HTML.
+   */
+  supportHtml: boolean;
+
+  /**
+   * Show the createdAt timestamp in the rendered toast.
+   */
+  showCreatedAt: boolean;
+  /**
+   * Format the createdAt timestamp when displayed.
+   */
+  createdAtFormatter: (createdAt: number) => string;
+
+  /**
+   * Called after the toast is added to state.
+   */
+  onMount?(ctx: ToastContext): void;
+
+  /**
+   * Called after the toast is removed from state.
+   */
+  onUnmount?(ctx: ToastContext): void;
+
+  /**
+   * Called when the toast is clicked.
+   */
+  onClick?(ctx: ToastContext, event: MouseEvent): void;
+
+  /**
+   * Called right before a toast starts leaving.
+   */
+  onClose?(ctx: ToastContext): void;
+}
+
+/**
+ * Fully resolved options applied to a toast instance.
+ */
+export interface ToastOptions extends ToastConfig {
+  type: ToastType;
+  title: string;
+  description: string;
+}
+
+/**
+ * Minimal text payload required to render a toast.
+ */
+export type ToastTextInput =
+  | { title: string; description?: string }
+  | { title?: string; description: string };
+
+/**
+ * Text payload with optional configuration overrides.
+ */
+export type ToastContentInput = ToastTextInput &
+  Partial<Omit<ToastOptions, "type" | "title" | "description">>;
+
+/**
+ * Payload required to create a toast.
+ */
+export type ToastShowInput = { type: ToastType } & ToastContentInput;
+
+/**
+ * Allowed fields when updating an existing toast.
+ */
+export type ToastUpdateInput = ToastContentInput &
+  Partial<Omit<ToastOptions, "title" | "description">>;
+
+/**
+ * Render instructions for the loading helper's success/error states.
+ */
+export type ToastLoadingRender<T> =
+  | ToastContentInput
+  | ((value: T) => ToastContentInput);
+
+/**
+ * Promise returned from the loading helper that also exposes the toast id.
+ */
+export type ToastLoadingResult<T> = Promise<T> & { toastId: ToastId };
+
+/**
+ * Concrete toast stored in state, including timing metadata.
+ */
+export interface ToastInstance extends ToastOptions {
+  id: ToastId;
+  createdAt: number;
+  phase?: ToastPhase;
+}
+
+/**
+ * Shape of the store's current state.
+ */
+export interface ToastState {
+  toasts: ToastInstance[];
+}
+
+/**
+ * Public API for interacting with the toast store.
+ */
+export interface ToastStore {
+  /**
+   * Return the current toast state snapshot.
+   */
+  getState(): ToastState;
+
+  /**
+   * Subscribe to state changes; immediately emits the current state.
+   */
+  subscribe(listener: (state: ToastState) => void): () => void;
+
+  /**
+   * Subscribe to one-off toast events such as duplicates or timer resets.
+   */
+  subscribeEvents(listener: (event: ToastEvent) => void): () => void;
+
+  /**
+   * Create and show a toast; returns its id.
+   */
+  show(options: ToastShowInput): ToastId;
+
+  /**
+   * Update an existing toast by id.
+   */
+  update(id: ToastId, options: ToastUpdateInput): void;
+
+  /**
+   * Dismiss a single toast by id.
+   */
+  dismiss(id: ToastId): void;
+
+  /**
+   * Dismiss all toasts at once.
+   */
+  dismissAll(): void;
+
+  /**
+   * Pause the auto-dismiss timer for a toast.
+   */
+  pause(id: ToastId): void;
+
+  /**
+   * Resume the auto-dismiss timer using the configured strategy.
+   */
+  resume(id: ToastId): void;
+
+  /**
+   * Return the resolved global configuration.
+   */
+  getConfig(): ToastConfig;
+
+  /**
+   * Wrap an async task with a loading toast that updates on completion.
+   */
+  loading<T>(
+    input: ToastLoadingInput<T>,
+    config: ToastLoadingConfig<T>,
+  ): ToastLoadingResult<T>;
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": [
+    "src"
+  ]
+}