svelora 3.0.14 → 3.0.16

package/dist/components/Toast/internal/french-toast/core/types.d.ts

@@ -0,0 +1,58 @@
+import type { Component } from 'svelte';
+import type { MouseEventHandler } from 'svelte/elements';
+export type ToastType = 'success' | 'error' | 'loading' | 'blank' | 'custom' | 'warning' | 'info';
+export type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+export type Renderable<T extends Record<string, unknown> = Record<string, unknown>> = Component<T> | string | null;
+export interface IconTheme {
+    primary: string;
+    secondary: string;
+}
+export type ValueFunction<TValue, TArg> = (arg: TArg) => TValue;
+export type ValueOrFunction<TValue, TArg> = TValue | ValueFunction<TValue, TArg>;
+export declare const resolveValue: <TValue, TArg>(valOrFunction: ValueOrFunction<TValue, TArg>, arg: TArg) => TValue;
+export interface ToastAction {
+    label: string;
+    onClick: MouseEventHandler<HTMLButtonElement>;
+}
+export interface Toast<T extends Record<string, unknown> = Record<string, unknown>> {
+    type: ToastType;
+    id: string;
+    message: Renderable<T>;
+    description?: Renderable;
+    icon?: Renderable;
+    duration?: number;
+    pauseDuration: number;
+    position?: ToastPosition;
+    props?: Omit<T, 'toast'>;
+    ariaProps: {
+        role: 'status' | 'alert';
+        'aria-live': 'assertive' | 'off' | 'polite';
+    };
+    style?: string;
+    className?: string;
+    descriptionClass?: string;
+    iconTheme?: IconTheme;
+    action?: ToastAction;
+    cancel?: ToastAction;
+    closeButton?: boolean;
+    createdAt: number;
+    visible: boolean;
+    height?: number;
+}
+export type DOMToast<T extends Record<string, unknown> = Record<string, unknown>> = Toast<T> & {
+    offset: number;
+};
+export type ToastOptions<T extends Record<string, unknown> = Record<string, unknown>> = Partial<Pick<Toast<T>, 'id' | 'icon' | 'description' | 'duration' | 'ariaProps' | 'className' | 'descriptionClass' | 'style' | 'position' | 'iconTheme' | 'props' | 'action' | 'cancel' | 'closeButton'>>;
+export type DefaultToastOptions = ToastOptions & {
+    [key in ToastType]?: ToastOptions;
+};
+export interface ToasterProps {
+    position?: ToastPosition;
+    toastOptions?: DefaultToastOptions;
+    reverseOrder?: boolean;
+    gutter?: number;
+    containerStyle?: string;
+    containerClassName?: string;
+    closeButton?: boolean;
+    theme?: 'light' | 'dark' | 'system';
+}

package/dist/components/Toast/internal/french-toast/core/types.js

@@ -0,0 +1,4 @@
+// Vendored from svelte-french-toast (MIT License)
+// https://github.com/kbrgl/svelte-french-toast
+const isFunction = (valOrFunction) => typeof valOrFunction === 'function';
+export const resolveValue = (valOrFunction, arg) => (isFunction(valOrFunction) ? valOrFunction(arg) : valOrFunction);

package/dist/components/Toast/internal/french-toast/core/use-toaster.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { DefaultToastOptions, Toast, ToastPosition } from './types.js';
+declare function calculateOffset(toastItem: Toast, list: Toast[], opts?: {
+    reverseOrder?: boolean;
+    gutter?: number;
+    defaultPosition?: ToastPosition;
+}): number;
+export declare function useToaster(getToastOptions?: () => DefaultToastOptions): {
+    readonly mergedToasts: Toast<Record<string, unknown>>[];
+    handlers: {
+        startPause(): void;
+        endPause(): void;
+        updateHeight: (toastId: string, height: number) => void;
+        calculateOffset: typeof calculateOffset;
+    };
+};
+export {};

package/dist/components/Toast/internal/french-toast/core/use-toaster.svelte.js

@@ -0,0 +1,71 @@
+// Vendored from svelte-french-toast (MIT License)
+// https://github.com/kbrgl/svelte-french-toast
+import toast from './toast.js';
+import { endPause as _endPause, mergeToastOptions, startPause as _startPause, toastStore, update } from './store.svelte.js';
+function calculateOffset(toastItem, list, opts) {
+    const { reverseOrder, gutter = 8, defaultPosition } = opts || {};
+    const relevantToasts = list.filter((t) => (t.position || defaultPosition) === (toastItem.position || defaultPosition) && t.height);
+    const toastIndex = relevantToasts.findIndex((t) => t.id === toastItem.id);
+    const toastsBefore = relevantToasts.filter((item, i) => i < toastIndex && item.visible).length;
+    const offset = relevantToasts
+        .filter((t) => t.visible)
+        .slice(...(reverseOrder ? [toastsBefore + 1] : [0, toastsBefore]))
+        .reduce((acc, t) => acc + (t.height || 0) + gutter, 0);
+    return offset;
+}
+const handlers = {
+    startPause() {
+        _startPause(Date.now());
+    },
+    endPause() {
+        _endPause(Date.now());
+    },
+    updateHeight: (toastId, height) => {
+        update({ id: toastId, height }, false);
+    },
+    calculateOffset
+};
+export function useToaster(getToastOptions = () => ({})) {
+    const timeouts = new Map();
+    const mergedToasts = $derived(mergeToastOptions(toastStore.toasts, getToastOptions()));
+    $effect(() => {
+        if (toastStore.pausedAt) {
+            for (const [, timeoutId] of timeouts) {
+                clearTimeout(timeoutId);
+            }
+            timeouts.clear();
+            return;
+        }
+        const now = Date.now();
+        for (const t of mergedToasts) {
+            if (timeouts.has(t.id)) {
+                continue;
+            }
+            if (t.duration === Number.POSITIVE_INFINITY) {
+                continue;
+            }
+            const durationLeft = (t.duration || 0) + t.pauseDuration - (now - t.createdAt);
+            if (durationLeft < 0) {
+                if (t.visible) {
+                    toast.dismiss(t.id);
+                }
+                continue;
+            }
+            timeouts.set(t.id, setTimeout(() => toast.dismiss(t.id), durationLeft));
+        }
+    });
+    $effect(() => {
+        return () => {
+            for (const [, timeoutId] of timeouts) {
+                clearTimeout(timeoutId);
+            }
+            timeouts.clear();
+        };
+    });
+    return {
+        get mergedToasts() {
+            return mergedToasts;
+        },
+        handlers
+    };
+}

package/dist/components/Toast/internal/french-toast/core/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const genId: () => string;
+export declare const prefersReducedMotion: () => boolean | undefined;
+export declare function parsePosition(position: string): {
+    xPosition: string;
+    yPosition: string;
+};

package/dist/components/Toast/internal/french-toast/core/utils.js

@@ -0,0 +1,25 @@
+// Vendored from svelte-french-toast (MIT License)
+// https://github.com/kbrgl/svelte-french-toast
+export const genId = (() => {
+    let count = 0;
+    return () => {
+        count += 1;
+        return count.toString();
+    };
+})();
+export const prefersReducedMotion = (() => {
+    let shouldReduceMotion;
+    return () => {
+        if (shouldReduceMotion === undefined && typeof window !== 'undefined') {
+            const mediaQuery = matchMedia('(prefers-reduced-motion: reduce)');
+            shouldReduceMotion = !mediaQuery || mediaQuery.matches;
+        }
+        return shouldReduceMotion;
+    };
+})();
+export function parsePosition(position) {
+    const [y = 'bottom', x = 'right'] = position.split('-');
+    const xPosition = x === 'center' ? 'center' : x === 'left' || x === 'start' ? 'left' : 'right';
+    const yPosition = y === 'top' ? 'top' : 'bottom';
+    return { xPosition, yPosition };
+}

package/dist/components/Toast/internal/french-toast/toast-context.d.ts

@@ -0,0 +1,18 @@
+import type { Snippet } from 'svelte';
+export type ToastIconSnippets = {
+    successIcon?: Snippet;
+    errorIcon?: Snippet;
+    warningIcon?: Snippet;
+    infoIcon?: Snippet;
+    loadingIcon?: Snippet;
+    closeIcon?: Snippet;
+};
+export type ToastIconTone = 'standard' | 'on-color';
+export type ToastToasterContext = ToastIconSnippets & {
+    closeButton?: boolean;
+    closeButtonAriaLabel?: string;
+    /** Use high-contrast icons on solid semantic backgrounds. */
+    iconTone?: ToastIconTone;
+};
+export declare function setToastToasterContext(getter: () => ToastToasterContext): void;
+export declare function getToastToasterContext(): ToastToasterContext;

package/dist/components/Toast/internal/french-toast/toast-context.js

@@ -0,0 +1,10 @@
+// Svelora extensions for vendored svelte-french-toast
+import { getContext, setContext } from 'svelte';
+const TOAST_TOASTER_CONTEXT = Symbol('svelora-toast-toaster');
+export function setToastToasterContext(getter) {
+    setContext(TOAST_TOASTER_CONTEXT, getter);
+}
+export function getToastToasterContext() {
+    const getter = getContext(TOAST_TOASTER_CONTEXT);
+    return getter?.() ?? {};
+}

package/dist/components/Toast/internal/notify.d.ts

@@ -0,0 +1,31 @@
+import type { ToastOptions as SveloraToastOptions } from '../toast.js';
+export interface NotifyOptions extends SveloraToastOptions {
+    /** Inline style map (merged into `style`). */
+    styles?: Record<string, string>;
+    /** Class map (merged into `class`). */
+    classes?: Record<string, string>;
+}
+export interface NotifyPromiseOptions<T = unknown> extends NotifyOptions {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((error: unknown) => string);
+    /** Treat API responses with `success: false` as errors. */
+    checkSuccess?: (data: T) => boolean;
+    loadingOptions?: NotifyOptions;
+    successOptions?: NotifyOptions;
+    errorOptions?: NotifyOptions;
+    /** Minimum time to show the loading toast (ms). Default 800. */
+    minDuration?: number;
+}
+export declare const notify: {
+    success(message: string, options?: NotifyOptions): string;
+    error(message: string | unknown, options?: NotifyOptions): string;
+    info(message: string, options?: NotifyOptions): string;
+    warning(message: string, options?: NotifyOptions): string;
+    loading(message: string, options?: NotifyOptions): string;
+    processing(message: string, options?: NotifyOptions): string;
+    default(message: string, options?: NotifyOptions): string;
+    promise<T>(promise: Promise<T>, options: NotifyPromiseOptions<T>): Promise<T>;
+    dismiss(id?: string | number): void;
+};
+export type NotifyUtility = typeof notify;

package/dist/components/Toast/internal/notify.js

@@ -0,0 +1,100 @@
+import { toast } from '../toast.js';
+import { ToastError, ToastInfo, ToastLoading, ToastSuccess, ToastWarning } from './toast-icons/index.js';
+function getErrorMessage(err) {
+    if (typeof err === 'string')
+        return err;
+    if (err instanceof Error)
+        return err.message;
+    if (err && typeof err === 'object') {
+        const obj = err;
+        if (typeof obj.message === 'string')
+            return obj.message;
+        if (typeof obj.error === 'string')
+            return obj.error;
+        return JSON.stringify(err);
+    }
+    return 'An unknown error occurred';
+}
+function mapNotifyOptions(options) {
+    if (!options)
+        return options;
+    const { styles, classes, ...rest } = options;
+    const resolved = { ...rest };
+    if (styles && Object.keys(styles).length > 0) {
+        const inline = Object.entries(styles)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join('; ');
+        resolved.style = [resolved.style, inline].filter(Boolean).join('; ');
+    }
+    if (classes && Object.keys(classes).length > 0) {
+        const classNames = Object.values(classes).join(' ');
+        resolved.class = [resolved.class, classNames].filter(Boolean).join(' ');
+    }
+    return resolved;
+}
+function withIcon(icon, options) {
+    const resolved = mapNotifyOptions(options);
+    if (!resolved)
+        return { icon };
+    if (resolved.icon !== undefined)
+        return resolved;
+    return { ...resolved, icon };
+}
+export const notify = {
+    success(message, options) {
+        return toast.success(message, withIcon(ToastSuccess, options));
+    },
+    error(message, options) {
+        return toast.error(getErrorMessage(message), withIcon(ToastError, options));
+    },
+    info(message, options) {
+        return toast.info(message, withIcon(ToastInfo, options));
+    },
+    warning(message, options) {
+        return toast.warning(message, withIcon(ToastWarning, options));
+    },
+    loading(message, options) {
+        return toast.loading(message, withIcon(ToastLoading, {
+            duration: Number.POSITIVE_INFINITY,
+            ...options
+        }));
+    },
+    processing(message, options) {
+        return toast.processing(message, options);
+    },
+    default(message, options) {
+        return toast(message, mapNotifyOptions(options));
+    },
+    promise(promise, options) {
+        const { loading, success, error, checkSuccess, loadingOptions, successOptions, errorOptions, minDuration = 800, ...rest } = options;
+        const toastId = notify.loading(loading, {
+            ...rest,
+            ...loadingOptions
+        });
+        const minDelay = new Promise((resolve) => setTimeout(resolve, minDuration));
+        Promise.all([Promise.resolve(promise), minDelay])
+            .then(([data]) => {
+            if (checkSuccess && !checkSuccess(data)) {
+                throw data;
+            }
+            const message = typeof success === 'function' ? success(data) : success;
+            notify.success(message, {
+                id: toastId,
+                ...rest,
+                ...successOptions
+            });
+        })
+            .catch((err) => {
+            const message = typeof error === 'function' ? error(err) : getErrorMessage(err);
+            notify.error(message, {
+                id: toastId,
+                ...rest,
+                ...errorOptions
+            });
+        });
+        return promise;
+    },
+    dismiss(id) {
+        toast.dismiss(id !== undefined ? String(id) : undefined);
+    }
+};

package/dist/components/Toast/internal/toast-icons/ToastError.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">import AnimatedIcon from "../AnimatedIcon.svelte";
+import { getToastToasterContext } from "../french-toast/toast-context.js";
+let { tone } = $props();
+const toasterContext = getToastToasterContext();
+const resolvedTone = $derived(tone ?? toasterContext.iconTone ?? "standard");
+</script>
+
+<AnimatedIcon type="error" size={24} tone={resolvedTone} forceMotion idle={false} />

package/dist/components/Toast/internal/toast-icons/ToastError.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ToastIconProps } from './toast-icon.types.js';
+declare const ToastError: import("svelte").Component<ToastIconProps, {}, "">;
+type ToastError = ReturnType<typeof ToastError>;
+export default ToastError;

package/dist/components/Toast/internal/toast-icons/ToastInfo.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">import AnimatedIcon from "../AnimatedIcon.svelte";
+import { getToastToasterContext } from "../french-toast/toast-context.js";
+let { tone } = $props();
+const toasterContext = getToastToasterContext();
+const resolvedTone = $derived(tone ?? toasterContext.iconTone ?? "standard");
+</script>
+
+<AnimatedIcon type="info" size={24} tone={resolvedTone} forceMotion idle={false} />

package/dist/components/Toast/internal/toast-icons/ToastInfo.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ToastIconProps } from './toast-icon.types.js';
+declare const ToastInfo: import("svelte").Component<ToastIconProps, {}, "">;
+type ToastInfo = ReturnType<typeof ToastInfo>;
+export default ToastInfo;

package/dist/components/Toast/internal/toast-icons/ToastLoading.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">import AnimatedIcon from "../AnimatedIcon.svelte";
+import { getToastToasterContext } from "../french-toast/toast-context.js";
+let { tone } = $props();
+const toasterContext = getToastToasterContext();
+const resolvedTone = $derived(tone ?? toasterContext.iconTone ?? "standard");
+</script>
+
+<AnimatedIcon type="loading" size={24} tone={resolvedTone} forceMotion idle={false} />

package/dist/components/Toast/internal/toast-icons/ToastLoading.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ToastIconProps } from './toast-icon.types.js';
+declare const ToastLoading: import("svelte").Component<ToastIconProps, {}, "">;
+type ToastLoading = ReturnType<typeof ToastLoading>;
+export default ToastLoading;

package/dist/components/Toast/internal/toast-icons/ToastProcessing.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">import AnimatedIcon from "../AnimatedIcon.svelte";
+import { getToastToasterContext } from "../french-toast/toast-context.js";
+let { tone } = $props();
+const toasterContext = getToastToasterContext();
+const resolvedTone = $derived(tone ?? toasterContext.iconTone ?? "standard");
+</script>
+
+<AnimatedIcon type="processing" size={24} tone={resolvedTone} forceMotion idle={false} />

package/dist/components/Toast/internal/toast-icons/ToastProcessing.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ToastIconProps } from './toast-icon.types.js';
+declare const ToastProcessing: import("svelte").Component<ToastIconProps, {}, "">;
+type ToastProcessing = ReturnType<typeof ToastProcessing>;
+export default ToastProcessing;

package/dist/components/Toast/internal/toast-icons/ToastSuccess.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">import AnimatedIcon from "../AnimatedIcon.svelte";
+import { getToastToasterContext } from "../french-toast/toast-context.js";
+let { tone } = $props();
+const toasterContext = getToastToasterContext();
+const resolvedTone = $derived(tone ?? toasterContext.iconTone ?? "standard");
+</script>
+
+<AnimatedIcon type="success" size={24} tone={resolvedTone} forceMotion idle={false} />

package/dist/components/Toast/internal/toast-icons/ToastSuccess.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ToastIconProps } from './toast-icon.types.js';
+declare const ToastSuccess: import("svelte").Component<ToastIconProps, {}, "">;
+type ToastSuccess = ReturnType<typeof ToastSuccess>;
+export default ToastSuccess;

package/dist/components/Toast/internal/toast-icons/ToastWarning.svelte

@@ -0,0 +1,8 @@
+<script lang="ts">import AnimatedIcon from "../AnimatedIcon.svelte";
+import { getToastToasterContext } from "../french-toast/toast-context.js";
+let { tone } = $props();
+const toasterContext = getToastToasterContext();
+const resolvedTone = $derived(tone ?? toasterContext.iconTone ?? "standard");
+</script>
+
+<AnimatedIcon type="warning" size={24} tone={resolvedTone} forceMotion idle={false} />

package/dist/components/Toast/internal/toast-icons/ToastWarning.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { ToastIconProps } from './toast-icon.types.js';
+declare const ToastWarning: import("svelte").Component<ToastIconProps, {}, "">;
+type ToastWarning = ReturnType<typeof ToastWarning>;
+export default ToastWarning;

package/dist/components/Toast/internal/toast-icons/index.d.ts

@@ -0,0 +1,6 @@
+export { default as ToastSuccess } from './ToastSuccess.svelte';
+export { default as ToastError } from './ToastError.svelte';
+export { default as ToastWarning } from './ToastWarning.svelte';
+export { default as ToastInfo } from './ToastInfo.svelte';
+export { default as ToastLoading } from './ToastLoading.svelte';
+export { default as ToastProcessing } from './ToastProcessing.svelte';

package/dist/components/Toast/internal/toast-icons/index.js

@@ -0,0 +1,6 @@
+export { default as ToastSuccess } from './ToastSuccess.svelte';
+export { default as ToastError } from './ToastError.svelte';
+export { default as ToastWarning } from './ToastWarning.svelte';
+export { default as ToastInfo } from './ToastInfo.svelte';
+export { default as ToastLoading } from './ToastLoading.svelte';
+export { default as ToastProcessing } from './ToastProcessing.svelte';

package/dist/components/Toast/internal/toast-icons/toast-icon.types.d.ts

@@ -0,0 +1,4 @@
+import type { ToastIconTone } from '../french-toast/toast-context.js';
+export type ToastIconProps = {
+    tone?: ToastIconTone;
+};

package/dist/components/Toast/internal/toast-icons/toast-icon.types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/Toast/toast.d.ts

@@ -1,38 +1,53 @@
-import type { ExternalToast } from 'svelte-sonner';
+import type { Component } from 'svelte';
+import type { ToastOptions, ValueOrFunction } from './internal/french-toast/core/types.js';
 import type { AvatarProps } from '../Avatar/avatar.types.js';
 import type { ToastColor } from './toast.variants.js';
 type ToastAvatarOptions = Pick<AvatarProps, 'src' | 'alt' | 'text' | 'icon' | 'size'>;
-type SveloraToastOptions = Omit<ExternalToast, 'icon'> & {
+type SveloraToastOptions = Omit<ToastOptions, 'icon' | 'className'> & {
     /**
      * Semantic color for the toast.
-     * Works with all Toaster variants (outline, soft, subtle, solid, accent).
      * @example toast('Message', { color: 'primary' })
      */
     color?: ToastColor;
     /**
      * Iconify icon name to display in the toast.
-     * Replaces the default type icon (success checkmark, error X, etc.)
      * @example toast('Launched!', { icon: 'lucide:rocket' })
      */
-    icon?: string | ExternalToast['icon'];
+    icon?: string | ToastOptions['icon'];
     /**
      * Avatar to display in the icon slot.
-     * Pass an object with Avatar props (src, alt, text, icon, size).
      * @example toast('John commented', { avatar: { src: '/avatar.jpg', alt: 'John' } })
      */
     avatar?: ToastAvatarOptions;
+    /**
+     * When false, toast stays until programmatically dismissed or updated.
+     * Also sets `duration: Infinity` and hides the close button.
+     */
+    dismissible?: boolean;
+    /** Alias for className. */
+    class?: string;
+};
+type SveloraPromiseOptions = SveloraToastOptions & {
+    loading?: SveloraToastOptions;
+    success?: SveloraToastOptions;
+    error?: SveloraToastOptions;
 };
-declare function toastFn(message: string, data?: SveloraToastOptions): string | number;
+declare function toastFn(message: string, data?: SveloraToastOptions): string;
 declare namespace toastFn {
-    var success: (message: string, data?: SveloraToastOptions) => string | number;
-    var error: (message: string, data?: SveloraToastOptions) => string | number;
-    var warning: (message: string, data?: SveloraToastOptions) => string | number;
-    var info: (message: string, data?: SveloraToastOptions) => string | number;
-    var loading: (message: string, data?: SveloraToastOptions) => string | number;
-    var promise;
-    var dismiss: (id?: number | string) => string | number | undefined;
-    var custom;
-    var message;
+    var success: (message: string, data?: SveloraToastOptions) => string;
+    var error: (message: string, data?: SveloraToastOptions) => string;
+    var warning: (message: string, data?: SveloraToastOptions) => string;
+    var info: (message: string, data?: SveloraToastOptions) => string;
+    var loading: (message: string, data?: SveloraToastOptions) => string;
+    var processing: (message: string, data?: SveloraToastOptions) => string;
+    var promise: <T>(promise: Promise<T>, msgs: {
+        loading: string;
+        success: ValueOrFunction<string, T>;
+        error: ValueOrFunction<string, unknown>;
+    }, opts?: SveloraPromiseOptions) => Promise<T>;
+    var dismiss: (toastId?: string) => void;
+    var custom: <T extends Record<string, unknown> = Record<string, unknown>>(message: string | Component<T, {}, string> | null, options?: ToastOptions<T>) => string;
+    var message: <T extends Record<string, unknown> = Record<string, unknown>>(message: string | Component<T, {}, string> | null, options?: ToastOptions<T>) => string;
 }
 export type { SveloraToastOptions as ToastOptions };
 export { toastFn as toast };

package/dist/components/Toast/toast.js

@@ -1,9 +1,10 @@
 import { mount, unmount } from 'svelte';
-import { toast as sonnerToast } from 'svelte-sonner';
+import internalToast from './internal/french-toast/core/toast.js';
+import ToastProcessing from './internal/toast-icons/ToastProcessing.svelte';
 import Avatar from '../Avatar/Avatar.svelte';
 import Icon from '../Icon/Icon.svelte';
 function createIconComponent(name) {
-    function SvelteSonnerIcon(anchor) {
+    function SveloraIcon(anchor) {
         if (!anchor.parentNode)
             return { destroy() { } };
         const instance = mount(Icon, {
@@ -17,10 +18,10 @@ function createIconComponent(name) {
             }
         };
     }
-    return SvelteSonnerIcon;
+    return SveloraIcon;
 }
 function createAvatarComponent(props) {
-    function SvelteSonnerAvatar(anchor) {
+    function SveloraAvatar(anchor) {
         if (!anchor.parentNode)
             return { destroy() { } };
         const instance = mount(Avatar, {
@@ -34,19 +35,24 @@ function createAvatarComponent(props) {
             }
         };
     }
-    return SvelteSonnerAvatar;
+    return SveloraAvatar;
 }
 function resolveOptions(data) {
     if (!data)
         return data;
-    const { color, icon, avatar, ...rest } = data;
+    const { color, icon, avatar, class: className, dismissible, ...rest } = data;
     const resolved = { ...rest };
-    // Color -> class
+    if (dismissible === false) {
+        resolved.duration = Number.POSITIVE_INFINITY;
+        resolved.closeButton = false;
+    }
+    if (className) {
+        resolved.className = className;
+    }
     if (color) {
-        const existing = resolved.class ?? '';
-        resolved.class = `${existing} ps-color-${color}`.trim();
+        const existing = resolved.className ?? '';
+        resolved.className = `${existing} ps-color-${color}`.trim();
     }
-    // Avatar takes priority over icon
     if (avatar) {
         resolved.icon = createAvatarComponent(avatar);
     }
@@ -58,16 +64,35 @@ function resolveOptions(data) {
     }
     return resolved;
 }
+function resolveDefaultOptions(opts) {
+    if (!opts)
+        return opts;
+    const { loading, success, error, ...rest } = opts;
+    return {
+        ...resolveOptions(rest),
+        loading: resolveOptions(loading),
+        success: resolveOptions(success),
+        error: resolveOptions(error)
+    };
+}
 function toastFn(message, data) {
-    return sonnerToast(message, resolveOptions(data));
+    return internalToast(message, resolveOptions(data));
 }
-toastFn.success = (message, data) => sonnerToast.success(message, resolveOptions(data));
-toastFn.error = (message, data) => sonnerToast.error(message, resolveOptions(data));
-toastFn.warning = (message, data) => sonnerToast.warning(message, resolveOptions(data));
-toastFn.info = (message, data) => sonnerToast.info(message, resolveOptions(data));
-toastFn.loading = (message, data) => sonnerToast.loading(message, resolveOptions(data));
-toastFn.promise = sonnerToast.promise;
-toastFn.dismiss = sonnerToast.dismiss;
-toastFn.custom = sonnerToast.custom;
-toastFn.message = sonnerToast.message;
+toastFn.success = (message, data) => internalToast.success(message, resolveOptions(data));
+toastFn.error = (message, data) => internalToast.error(message, resolveOptions(data));
+toastFn.warning = (message, data) => internalToast.warning(message, resolveOptions(data));
+toastFn.info = (message, data) => internalToast.info(message, resolveOptions(data));
+toastFn.loading = (message, data) => internalToast.loading(message, resolveOptions(data));
+toastFn.processing = (message, data) => {
+    const resolved = resolveOptions({
+        duration: Number.POSITIVE_INFINITY,
+        ...data,
+        icon: data?.icon ?? ToastProcessing
+    });
+    return internalToast.loading(message, resolved);
+};
+toastFn.promise = (promise, msgs, opts) => internalToast.promise(promise, msgs, resolveDefaultOptions(opts));
+toastFn.dismiss = internalToast.dismiss;
+toastFn.custom = internalToast.custom;
+toastFn.message = internalToast.message;
 export { toastFn as toast };