gbs-add-block 1.2.11 → 1.2.13

package/source/beta-components/toaster/__tests__/core.test.ts

@@ -0,0 +1,256 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createToastApi } from "../core/api";
+import { createToastStore, visibleToasts, type ToastStore } from "../core/store";
+import { toast, toastStore } from "../core/toast";
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+const states = (store: ToastStore) =>
+  store.getSnapshot().toasts.map((item) => `${item.id}:${item.state}`);
+
+const find = (store: ToastStore, id: string) =>
+  store.getSnapshot().toasts.find((item) => item.id === id);
+
+describe("showing", () => {
+  it("adds toasts newest first, with defaults", () => {
+    const store = createToastStore();
+    const first = store.show("Saved");
+    const second = store.show("Deleted", { type: "error", description: "3 rows" });
+
+    expect([first, second]).toEqual(["toast-1", "toast-2"]);
+    const [newest, oldest] = store.getSnapshot().toasts;
+    expect(newest).toMatchObject({ id: "toast-2", type: "error", description: "3 rows" });
+    expect(oldest).toMatchObject({
+      title: "Saved",
+      type: "default",
+      duration: 5000,
+      dismissible: true,
+      state: "open",
+      version: 1,
+    });
+  });
+
+  it("updates a toast shown again with the same id, keeping its place", () => {
+    const store = createToastStore();
+    store.show("Syncing", { id: "sync" });
+    store.show("Other");
+    store.show("Synced", { id: "sync", type: "success" });
+
+    expect(states(store)).toEqual(["toast-1:open", "sync:open"]);
+    expect(find(store, "sync")).toMatchObject({ title: "Synced", type: "success", version: 2 });
+  });
+
+  it("restarts the countdown when the same id is shown again", () => {
+    const store = createToastStore();
+    store.show("Draft saved", { id: "draft" });
+    vi.advanceTimersByTime(4000);
+    store.show("Draft saved again", { id: "draft" });
+    vi.advanceTimersByTime(4000);
+    expect(find(store, "draft")?.state).toBe("open");
+    vi.advanceTimersByTime(1000);
+    expect(find(store, "draft")?.state).toBe("closing");
+  });
+
+  it("brings back a toast that is fading out instead of stacking a copy", () => {
+    const store = createToastStore();
+    store.show("Offline", { id: "net" });
+    store.dismiss("net");
+    store.show("Still offline", { id: "net" });
+    vi.advanceTimersByTime(300);
+    expect(states(store)).toEqual(["net:open"]);
+  });
+});
+
+describe("timing", () => {
+  it("closes after its duration, then leaves after the exit animation", () => {
+    const store = createToastStore();
+    const onAutoClose = vi.fn();
+    const onDismiss = vi.fn();
+    store.show("Saved", { duration: 2000, onAutoClose, onDismiss });
+
+    vi.advanceTimersByTime(1999);
+    expect(states(store)).toEqual(["toast-1:open"]);
+    vi.advanceTimersByTime(1);
+    expect(states(store)).toEqual(["toast-1:closing"]);
+    expect(onAutoClose).toHaveBeenCalledOnce();
+    expect(onDismiss).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(200);
+    expect(states(store)).toEqual([]);
+  });
+
+  it("keeps sticky and loading toasts until dismissed", () => {
+    const store = createToastStore();
+    store.show("Zero", { duration: 0 });
+    store.show("Infinite", { duration: Infinity });
+    store.show("Working", { type: "loading" });
+
+    vi.advanceTimersByTime(60_000);
+    expect(states(store)).toEqual(["toast-3:open", "toast-2:open", "toast-1:open"]);
+    expect(find(store, "toast-1")?.duration).toBe(Infinity);
+  });
+
+  it("dismisses one toast or all of them", () => {
+    const store = createToastStore();
+    const onDismiss = vi.fn();
+    store.show("A", { onDismiss });
+    store.show("B");
+    store.show("C");
+
+    store.dismiss("toast-1");
+    expect(onDismiss).toHaveBeenCalledWith(expect.objectContaining({ id: "toast-1" }));
+    expect(states(store)).toEqual(["toast-3:open", "toast-2:open", "toast-1:closing"]);
+
+    store.dismiss();
+    vi.advanceTimersByTime(200);
+    expect(states(store)).toEqual([]);
+  });
+
+  it("holds the remaining time while paused", () => {
+    const store = createToastStore();
+    store.show("Saved");
+
+    vi.advanceTimersByTime(3000);
+    store.pause();
+    vi.advanceTimersByTime(10_000);
+    expect(states(store)).toEqual(["toast-1:open"]);
+
+    store.resume();
+    vi.advanceTimersByTime(1999);
+    expect(states(store)).toEqual(["toast-1:open"]);
+    vi.advanceTimersByTime(1);
+    expect(states(store)).toEqual(["toast-1:closing"]);
+  });
+
+  it("queues toasts beyond the limit with their full time", () => {
+    const store = createToastStore({ limit: 3 });
+    for (const title of ["A", "B", "C", "D"]) store.show(title);
+
+    expect(visibleToasts(store.getSnapshot()).map((item) => item.title)).toEqual(["D", "C", "B"]);
+
+    // B, C and D run out; A only starts counting once it gets a slot.
+    vi.advanceTimersByTime(5000);
+    expect(find(store, "toast-1")?.state).toBe("open");
+    expect(visibleToasts(store.getSnapshot()).map((item) => item.title)).toEqual([
+      "D",
+      "C",
+      "B",
+      "A",
+    ]);
+    vi.advanceTimersByTime(4999);
+    expect(find(store, "toast-1")?.state).toBe("open");
+    vi.advanceTimersByTime(1);
+    expect(find(store, "toast-1")?.state).toBe("closing");
+  });
+});
+
+describe("updates", () => {
+  it("gives a loading toast a normal duration once its type changes", () => {
+    const store = createToastStore();
+    const id = store.show("Uploading", { type: "loading" });
+
+    store.update(id, { description: "40%" });
+    expect(find(store, id)).toMatchObject({ duration: Infinity, description: "40%", version: 2 });
+
+    store.update(id, { type: "success", title: "Uploaded" });
+    expect(find(store, id)).toMatchObject({ type: "success", title: "Uploaded", duration: 5000 });
+    vi.advanceTimersByTime(5000);
+    expect(find(store, id)?.state).toBe("closing");
+  });
+
+  it("ignores ids that are not open", () => {
+    const store = createToastStore();
+    store.update("missing", { title: "Nope" });
+    expect(states(store)).toEqual([]);
+  });
+
+  it("applies a new limit and notifies subscribers", () => {
+    const store = createToastStore();
+    const listener = vi.fn();
+    store.subscribe(listener);
+
+    store.configure({ limit: 1, duration: undefined });
+    expect(store.getSnapshot().limit).toBe(1);
+    expect(listener).toHaveBeenCalledOnce();
+
+    store.pause();
+    store.pause();
+    expect(listener).toHaveBeenCalledTimes(2);
+  });
+
+  it("keeps the same snapshot object until something changes", () => {
+    const store = createToastStore();
+    const before = store.getSnapshot();
+    expect(store.getSnapshot()).toBe(before);
+    store.show("Hi");
+    expect(store.getSnapshot()).not.toBe(before);
+  });
+});
+
+describe("toast api", () => {
+  it("sets the type from the shortcut used", () => {
+    const store = createToastStore();
+    const api = createToastApi(store);
+    api.success("Saved");
+    api.warning("Low disk");
+    api.custom(({ id }) => id);
+
+    const [custom, warning, success] = store.getSnapshot().toasts;
+    expect(success.type).toBe("success");
+    expect(warning.type).toBe("warning");
+    expect(typeof custom.render).toBe("function");
+  });
+
+  it("turns a promise into a success toast", async () => {
+    const store = createToastStore();
+    const api = createToastApi(store);
+    const result = api.promise(Promise.resolve(42), {
+      loading: "Saving",
+      success: (value) => `Saved ${value}`,
+      error: "Failed",
+    });
+
+    expect(store.getSnapshot().toasts[0]).toMatchObject({ type: "loading", title: "Saving" });
+    await expect(result).resolves.toBe(42);
+    expect(store.getSnapshot().toasts[0]).toMatchObject({ type: "success", title: "Saved 42" });
+  });
+
+  it("turns a rejected promise into an error toast and still rejects", async () => {
+    const store = createToastStore();
+    const api = createToastApi(store);
+    const result = api.promise(() => Promise.reject(new Error("Network down")), {
+      loading: "Saving",
+      error: (error) => (error as Error).message,
+    });
+
+    await expect(result).rejects.toThrow("Network down");
+    expect(store.getSnapshot().toasts[0]).toMatchObject({ type: "error", title: "Network down" });
+  });
+
+  it("closes quietly when a promise message is left out", async () => {
+    const store = createToastStore();
+    const api = createToastApi(store);
+    await api.promise(Promise.resolve("ok"), { loading: "Checking" });
+    expect(states(store)).toEqual(["toast-1:closing"]);
+  });
+
+  it("does nothing where a toast cannot be shown", async () => {
+    const store = createToastStore();
+    const api = createToastApi(store, () => false);
+    expect(api("Hidden")).toBe("");
+    expect(api.success("Hidden", { id: "kept" })).toBe("kept");
+    await expect(api.promise(Promise.resolve(1), { loading: "…" })).resolves.toBe(1);
+    expect(states(store)).toEqual([]);
+  });
+
+  it("ignores the default toast() on a server, where there is no document", () => {
+    expect(typeof document).toBe("undefined");
+    expect(toast("Rendered on the server")).toBe("");
+    expect(toastStore.getSnapshot().toasts).toHaveLength(0);
+  });
+});

package/source/beta-components/toaster/core/api.ts

@@ -0,0 +1,87 @@
+import type { ReactNode } from "react";
+import type { ToastPatch, ToastStore } from "./store";
+import type { ToastOptions, ToastRenderProps, ToastType } from "./types";
+
+type TypedOptions = Omit<ToastOptions, "type">;
+type Message<T> = ReactNode | ((value: T) => ReactNode);
+
+export interface PromiseMessages<T> {
+  loading: ReactNode;
+  /** Omit to close the toast quietly on success. */
+  success?: Message<T>;
+  /** Omit to close the toast quietly on failure. */
+  error?: Message<unknown>;
+}
+
+export interface ToastApi {
+  (title: ReactNode, options?: ToastOptions): string;
+  success(title: ReactNode, options?: TypedOptions): string;
+  error(title: ReactNode, options?: TypedOptions): string;
+  warning(title: ReactNode, options?: TypedOptions): string;
+  info(title: ReactNode, options?: TypedOptions): string;
+  /** Stays until updated or dismissed. */
+  loading(title: ReactNode, options?: TypedOptions): string;
+  custom(
+    render: (props: ToastRenderProps) => ReactNode,
+    options?: Omit<TypedOptions, "render">,
+  ): string;
+  /** Shows a loading toast, then turns it into a success or error. Returns the same promise. */
+  promise<T>(
+    input: Promise<T> | (() => Promise<T>),
+    messages: PromiseMessages<T>,
+    options?: TypedOptions,
+  ): Promise<T>;
+  update(id: string, patch: ToastPatch): void;
+  dismiss(id?: string): void;
+}
+
+/**
+ * The `toast()` function for a store. `canShow` lets the default instance ignore
+ * calls made where nobody can see them, such as during a server render.
+ */
+export function createToastApi(store: ToastStore, canShow: () => boolean = () => true): ToastApi {
+  const show = (title: ReactNode, options?: ToastOptions) =>
+    canShow() ? store.show(title, options) : (options?.id ?? "");
+
+  const typed = (type: ToastType) => (title: ReactNode, options?: TypedOptions) =>
+    show(title, { ...options, type });
+
+  function promise<T>(
+    input: Promise<T> | (() => Promise<T>),
+    messages: PromiseMessages<T>,
+    options?: TypedOptions,
+  ): Promise<T> {
+    const pending = typeof input === "function" ? input() : input;
+    if (!canShow()) return pending;
+
+    const id = store.show(messages.loading, { ...options, type: "loading" });
+
+    function settle<V>(type: "success" | "error", message: Message<V> | undefined, value: V) {
+      if (message === undefined) store.dismiss(id);
+      else store.update(id, { type, title: typeof message === "function" ? message(value) : message });
+    }
+
+    // Handling the rejection here also stops it being reported as unhandled when
+    // the caller doesn't await the returned promise.
+    pending.then(
+      (value) => settle("success", messages.success, value),
+      (error: unknown) => settle("error", messages.error, error),
+    );
+    return pending;
+  }
+
+  return Object.assign(show, {
+    success: typed("success"),
+    error: typed("error"),
+    warning: typed("warning"),
+    info: typed("info"),
+    loading: typed("loading"),
+    custom: (
+      render: (props: ToastRenderProps) => ReactNode,
+      options?: Omit<TypedOptions, "render">,
+    ) => show(null, { ...options, render }),
+    promise,
+    update: (id: string, patch: ToastPatch) => store.update(id, patch),
+    dismiss: (id?: string) => store.dismiss(id),
+  });
+}

package/source/beta-components/toaster/core/index.ts

@@ -0,0 +1,14 @@
+// Framework-free: the store, the timers and the `toast()` API run without
+// React, so they can be called from a data layer and tested on their own.
+export { createToastApi } from "./api";
+export type { PromiseMessages, ToastApi } from "./api";
+export {
+  createToastStore,
+  DEFAULT_DURATION,
+  DEFAULT_LIMIT,
+  EXIT_DURATION,
+  visibleToasts,
+} from "./store";
+export type { ToastPatch, ToastStore, ToastStoreConfig } from "./store";
+export { toast, toastStore } from "./toast";
+export type * from "./types";

package/source/beta-components/toaster/core/store.ts

@@ -0,0 +1,211 @@
+import type { ReactNode } from "react";
+import type { ToastOptions, ToastRecord, ToastSnapshot } from "./types";
+
+export const DEFAULT_DURATION = 5000;
+export const DEFAULT_LIMIT = 3;
+/** Matches the CSS exit transition, so a toast fades out before it leaves the DOM. */
+export const EXIT_DURATION = 200;
+
+export interface ToastStoreConfig {
+  /** Default auto-close delay in milliseconds. */
+  duration?: number;
+  /** Open toasts on screen at once; the rest wait with their timers held. */
+  limit?: number;
+  /** How long a closed toast stays for its exit animation. */
+  exitDuration?: number;
+}
+
+export type ToastPatch = Omit<ToastOptions, "id"> & { title?: ReactNode };
+
+export interface ToastStore {
+  subscribe(listener: () => void): () => void;
+  getSnapshot(): ToastSnapshot;
+  getServerSnapshot(): ToastSnapshot;
+  /** Adds a toast, or updates the one with the same `id`. Returns the id. */
+  show(title: ReactNode, options?: ToastOptions): string;
+  /** Changes an open toast. A new `type` without a `duration` gets that type's default. */
+  update(id: string, patch: ToastPatch): void;
+  /** Closes one toast, or every toast when no id is given. */
+  dismiss(id?: string): void;
+  pause(): void;
+  resume(): void;
+  configure(config: ToastStoreConfig): void;
+}
+
+interface Countdown {
+  remaining: number;
+  startedAt: number;
+  handle: ReturnType<typeof setTimeout> | null;
+}
+
+const EMPTY: ToastSnapshot = { toasts: [], paused: false, limit: DEFAULT_LIMIT };
+
+/** What a Toaster renders: every closing toast, plus the newest `limit` open ones. */
+export function visibleToasts(snapshot: ToastSnapshot): ToastRecord[] {
+  let open = 0;
+  return snapshot.toasts.filter((toast) => toast.state !== "open" || open++ < snapshot.limit);
+}
+
+function definedOnly<T extends object>(value: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entry]) => entry !== undefined),
+  ) as Partial<T>;
+}
+
+/**
+ * Toast state and timers, with no React. Snapshots are immutable, so the store
+ * plugs straight into `useSyncExternalStore`. Only toasts on screen count down:
+ * one waiting beyond `limit` keeps its full time until it gets a slot.
+ */
+export function createToastStore(config: ToastStoreConfig = {}): ToastStore {
+  let settings: Required<ToastStoreConfig> = {
+    duration: DEFAULT_DURATION,
+    limit: DEFAULT_LIMIT,
+    exitDuration: EXIT_DURATION,
+    ...definedOnly(config),
+  };
+  let snapshot: ToastSnapshot = { ...EMPTY, limit: settings.limit };
+  let counter = 0;
+  const listeners = new Set<() => void>();
+  const countdowns = new Map<string, Countdown>();
+  const removals = new Map<string, ReturnType<typeof setTimeout>>();
+
+  function stop(id: string) {
+    const countdown = countdowns.get(id);
+    if (!countdown?.handle) return;
+    clearTimeout(countdown.handle);
+    countdown.handle = null;
+    countdown.remaining = Math.max(0, countdown.remaining - (Date.now() - countdown.startedAt));
+  }
+
+  function syncTimers() {
+    const visible = new Set(visibleToasts(snapshot));
+    for (const toast of snapshot.toasts) {
+      const countdown = countdowns.get(toast.id);
+      if (!countdown || toast.state !== "open") continue;
+      const run =
+        visible.has(toast) && !snapshot.paused && Number.isFinite(countdown.remaining);
+      if (run && !countdown.handle) {
+        countdown.startedAt = Date.now();
+        countdown.handle = setTimeout(() => close(toast.id, true), countdown.remaining);
+      } else if (!run && countdown.handle) {
+        stop(toast.id);
+      }
+    }
+  }
+
+  function commit(
+    toasts: readonly ToastRecord[],
+    changes: Partial<Omit<ToastSnapshot, "toasts">> = {},
+  ) {
+    snapshot = { ...snapshot, ...changes, toasts };
+    syncTimers();
+    for (const listener of listeners) listener();
+  }
+
+  function close(id: string, auto: boolean) {
+    const toast = snapshot.toasts.find((item) => item.id === id && item.state === "open");
+    if (!toast) return;
+    stop(id);
+    countdowns.delete(id);
+
+    const closing: ToastRecord = { ...toast, state: "closing" };
+    commit(snapshot.toasts.map((item) => (item === toast ? closing : item)));
+    if (auto) closing.onAutoClose?.(closing);
+    else closing.onDismiss?.(closing);
+
+    removals.set(
+      id,
+      setTimeout(() => {
+        removals.delete(id);
+        commit(snapshot.toasts.filter((item) => item !== closing));
+      }, settings.exitDuration),
+    );
+  }
+
+  function show(title: ReactNode, options: ToastOptions = {}): string {
+    const id = options.id ?? `toast-${++counter}`;
+    const type = options.type ?? "default";
+    const existing = snapshot.toasts.find((item) => item.id === id);
+    const reused = existing?.state === "open" ? existing : undefined;
+    const requested = options.duration ?? (type === "loading" ? Infinity : settings.duration);
+
+    const record: ToastRecord = {
+      ...options,
+      id,
+      type,
+      title,
+      // 0, negative and NaN all mean "stay until dismissed".
+      duration: requested > 0 ? requested : Infinity,
+      dismissible: options.dismissible ?? true,
+      state: "open",
+      createdAt: reused?.createdAt ?? Date.now(),
+      version: (existing?.version ?? 0) + 1,
+    };
+
+    // Showing an id that is fading out brings it back instead of stacking a copy.
+    const removal = removals.get(id);
+    if (removal !== undefined) {
+      clearTimeout(removal);
+      removals.delete(id);
+    }
+    stop(id);
+    countdowns.set(id, { remaining: record.duration, startedAt: 0, handle: null });
+
+    commit(
+      reused
+        ? snapshot.toasts.map((item) => (item === reused ? record : item))
+        : [record, ...snapshot.toasts.filter((item) => item.id !== id)],
+    );
+    return id;
+  }
+
+  function update(id: string, patch: ToastPatch) {
+    const existing = snapshot.toasts.find((item) => item.id === id && item.state === "open");
+    if (!existing) return;
+    const { title = existing.title, ...changes } = patch;
+    const typeChanged = changes.type !== undefined && changes.type !== existing.type;
+    show(title, {
+      ...existing,
+      ...changes,
+      id,
+      duration: changes.duration ?? (typeChanged ? undefined : existing.duration),
+    });
+  }
+
+  function dismiss(id?: string) {
+    if (id !== undefined) {
+      close(id, false);
+      return;
+    }
+    for (const toast of snapshot.toasts) {
+      if (toast.state === "open") close(toast.id, false);
+    }
+  }
+
+  function setPaused(paused: boolean) {
+    if (snapshot.paused !== paused) commit(snapshot.toasts, { paused });
+  }
+
+  function configure(next: ToastStoreConfig) {
+    settings = { ...settings, ...definedOnly(next) };
+    if (settings.limit !== snapshot.limit) commit(snapshot.toasts, { limit: settings.limit });
+  }
+
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot: () => snapshot,
+    getServerSnapshot: () => EMPTY,
+    show,
+    update,
+    dismiss,
+    pause: () => setPaused(true),
+    resume: () => setPaused(false),
+    configure,
+  };
+}

package/source/beta-components/toaster/core/toast.ts

@@ -0,0 +1,12 @@
+import { createToastApi } from "./api";
+import { createToastStore } from "./store";
+
+/** The store behind `toast()`, and behind any `<Toaster />` without a `store` prop. */
+export const toastStore = createToastStore();
+
+/**
+ * Shows a notification from anywhere: components, event handlers, data layers,
+ * code outside React. On a server nobody can see a toast, so calls do nothing
+ * there — which also keeps one request's toasts from leaking into another's.
+ */
+export const toast = createToastApi(toastStore, () => typeof document !== "undefined");

package/source/beta-components/toaster/core/types.ts

@@ -0,0 +1,78 @@
+import type { ReactNode } from "react";
+
+export type ToastType = "default" | "success" | "error" | "warning" | "info" | "loading";
+
+export type ToastPosition =
+  | "top-left"
+  | "top-center"
+  | "top-right"
+  | "bottom-left"
+  | "bottom-center"
+  | "bottom-right";
+
+/** The click event handed to an action. Call `preventDefault()` to keep the toast open. */
+export interface ToastActionEvent {
+  preventDefault(): void;
+  readonly defaultPrevented: boolean;
+}
+
+export interface ToastAction {
+  label: ReactNode;
+  onClick(event: ToastActionEvent): void;
+}
+
+export interface ToastRenderProps {
+  id: string;
+  dismiss(): void;
+}
+
+export interface ToastOptions {
+  /** Showing a toast with an id that is already on screen updates it in place. */
+  id?: string;
+  type?: ToastType;
+  description?: ReactNode;
+  /** Milliseconds before it closes. `0` or `Infinity` keeps it until dismissed. */
+  duration?: number;
+  /** Close button, Escape and swipe. Default true. */
+  dismissible?: boolean;
+  action?: ToastAction;
+  cancel?: ToastAction;
+  /** Replaces the type's icon; `null` hides it. */
+  icon?: ReactNode;
+  className?: string;
+  /** Renders the whole toast body yourself. */
+  render?(props: ToastRenderProps): ReactNode;
+  /** Closed by the user or by code. */
+  onDismiss?(toast: ToastRecord): void;
+  /** Closed because its time ran out. */
+  onAutoClose?(toast: ToastRecord): void;
+}
+
+export interface ToastRecord
+  extends Omit<ToastOptions, "id" | "type" | "duration" | "dismissible"> {
+  id: string;
+  type: ToastType;
+  title: ReactNode;
+  /** Always a positive number; `Infinity` when it stays until dismissed. */
+  duration: number;
+  dismissible: boolean;
+  /** `closing` while the exit animation plays, just before removal. */
+  state: "open" | "closing";
+  createdAt: number;
+  /** Goes up each time the same id is shown or updated. */
+  version: number;
+}
+
+export interface ToastSnapshot {
+  /** Newest first, including toasts waiting beyond `limit`. */
+  toasts: readonly ToastRecord[];
+  /** Timers are held, e.g. while the pointer is over the toasts. */
+  paused: boolean;
+  /** How many open toasts are on screen at once. */
+  limit: number;
+}
+
+export interface ToasterLocaleText {
+  regionLabel(hotkey: string): string;
+  close: string;
+}

package/source/beta-components/toaster/index.ts

@@ -0,0 +1,6 @@
+export { Toaster } from "./react/Toaster";
+export type { ToasterProps } from "./react/Toaster";
+export { useToasts } from "./react/useToasts";
+export { defaultToasterText } from "./react/locale";
+export type { ToasterSlot } from "./react/props";
+export * from "./core";