vue-toast-kit 1.0.0

package/dist/vue-toast-kit.d.ts

@@ -0,0 +1,540 @@
+import { Component } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { DefineComponent } from 'vue';
+import { ExtractPropTypes } from 'vue';
+import { Plugin as Plugin_2 } from 'vue';
+import { PropType } from 'vue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { ShallowReactive } from 'vue';
+import { VNode } from 'vue';
+
+declare const __VLS_component: DefineComponent<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+position?: ToastPosition;
+maxVisible?: number;
+gap?: number;
+offsetX?: number;
+offsetY?: number;
+zIndex?: number;
+expand?: boolean;
+teleportTo?: string;
+context?: ToastContext;
+theme?: "light" | "dark" | "system" | ToastDesignTokens;
+stackMode?: boolean;
+}>, {
+position: string;
+maxVisible: number;
+gap: number;
+offsetX: number;
+offsetY: number;
+zIndex: number;
+expand: boolean;
+teleportTo: string;
+stackMode: boolean;
+}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+position?: ToastPosition;
+maxVisible?: number;
+gap?: number;
+offsetX?: number;
+offsetY?: number;
+zIndex?: number;
+expand?: boolean;
+teleportTo?: string;
+context?: ToastContext;
+theme?: "light" | "dark" | "system" | ToastDesignTokens;
+stackMode?: boolean;
+}>, {
+position: string;
+maxVisible: number;
+gap: number;
+offsetX: number;
+offsetY: number;
+zIndex: number;
+expand: boolean;
+teleportTo: string;
+stackMode: boolean;
+}>>> & Readonly<{}>, {
+position: ToastPosition;
+maxVisible: number;
+gap: number;
+offsetX: number;
+offsetY: number;
+zIndex: number;
+expand: boolean;
+teleportTo: string;
+stackMode: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare const __VLS_component_2: DefineComponent<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_2<{
+toast: ToastItem;
+onDismiss: (id: string) => void;
+onGroupToggle?: (groupKey: string) => void;
+}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_2<{
+toast: ToastItem;
+onDismiss: (id: string) => void;
+onGroupToggle?: (groupKey: string) => void;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+
+declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;
+
+declare type __VLS_NonUndefinedable_3<T> = T extends undefined ? never : T;
+
+declare type __VLS_NonUndefinedable_4<T> = T extends undefined ? never : T;
+
+declare type __VLS_NonUndefinedable_5<T> = T extends undefined ? never : T;
+
+declare type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+declare function __VLS_template(): Readonly<{
+    toast(props: {
+        toast: ToastItem;
+        dismiss: (id: string) => void;
+    }): void;
+    'toast-icon'(props: {
+        toast: ToastItem;
+    }): void;
+    'toast-content'(props: {
+        toast: ToastItem;
+    }): void;
+    'toast-action'(props: {
+        toast: ToastItem;
+    }): void;
+    'toast-close'(props: {
+        toast: ToastItem;
+        dismiss: (id: string) => void;
+    }): void;
+    'toast-undo'(props: {
+        toast: ToastItem;
+        remaining: number;
+    }): void;
+}> & {
+    toast(props: {
+        toast: ToastItem;
+        dismiss: (id: string) => void;
+    }): void;
+    'toast-icon'(props: {
+        toast: ToastItem;
+    }): void;
+    'toast-content'(props: {
+        toast: ToastItem;
+    }): void;
+    'toast-action'(props: {
+        toast: ToastItem;
+    }): void;
+    'toast-close'(props: {
+        toast: ToastItem;
+        dismiss: (id: string) => void;
+    }): void;
+    'toast-undo'(props: {
+        toast: ToastItem;
+        remaining: number;
+    }): void;
+};
+
+declare function __VLS_template_2(): {
+    "toast-icon"?(_: {
+        toast: ToastItem;
+    }): any;
+    "toast-content"?(_: {
+        toast: ToastItem;
+    }): any;
+    "toast-action"?(_: {
+        toast: ToastItem;
+    }): any;
+    "toast-close"?(_: {
+        toast: ToastItem;
+        dismiss: typeof dismissWithFocusReturn;
+    }): any;
+    "toast-undo"?(_: {
+        toast: ToastItem;
+        remaining: number;
+    }): any;
+};
+
+declare type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare type __VLS_TypePropsToRuntimeProps_2<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable_2<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare type __VLS_TypePropsToRuntimeProps_3<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable_3<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare type __VLS_TypePropsToRuntimeProps_4<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable_4<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare type __VLS_TypePropsToRuntimeProps_5<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable_5<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+
+declare type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare interface BufferedToast {
+    message: string | VNode;
+    options: ToastOptions;
+}
+
+declare function buildToastApi(ctx: ToastContext): {
+    (message: string, options?: ToastOptions): string;
+    success(message: string, options?: ToastOptions): string;
+    error(message: string, options?: ToastOptions): string;
+    warning(message: string, options?: ToastOptions): string;
+    info(message: string, options?: ToastOptions): string;
+    loading(message: string, options?: ToastOptions): string;
+    custom(component: Component, options?: ToastOptions): string;
+    dismiss(id?: string): void;
+    update(id: string, partial: Partial<ToastOptions> & {
+        message?: string | VNode;
+    }): void;
+    updateMessage(id: string, message: string | VNode): void;
+    isActive(id: string): boolean;
+    promise<T>(promise: Promise<T>, messages: PromiseToastMessages<T>, options?: ToastOptions): Promise<T>;
+    undo(message: string, options: ToastOptions & {
+        undo: NonNullable<ToastOptions["undo"]>;
+    }): string;
+    dismissAll(position?: ToastPosition): void;
+    pauseAll(): void;
+    resumeAll(): void;
+};
+
+export declare function createToastContext(opts?: GlobalToastOptions): ToastContext;
+
+export declare const DEFAULT_OPTIONS: Required<Omit<ToastOptions, 'id' | 'component' | 'componentProps' | 'icon' | 'action' | 'undo' | 'groupKey' | 'theme' | 'onClose' | 'onAutoClose' | 'ariaLive' | 'position'>>;
+
+declare function dismissWithFocusReturn(id: string): void;
+
+declare type EventListener_2<T extends unknown[]> = (...args: T) => void;
+
+export declare function getOrCreateGlobalContext(opts?: GlobalToastOptions): ToastContext;
+
+export declare const globalBuffer: ToastBuffer;
+
+export declare interface GlobalToastOptions {
+    position?: ToastPosition;
+    maxVisible?: number;
+    duration?: number;
+    theme?: 'light' | 'dark' | 'system';
+    ignoreSSR?: boolean;
+    pauseOnHover?: boolean;
+    pauseOnFocusLoss?: boolean;
+    closable?: boolean;
+    /** Max toasts added within rateLimitWindowMs before extras are dropped. */
+    rateLimit?: number;
+    /** Window in ms for rateLimit (default: 1000). */
+    rateLimitWindowMs?: number;
+    /** Enable automatic localStorage persist/restore for toasts with persist:true. */
+    persistStorage?: boolean;
+}
+
+export declare class GroupManager {
+    private groups;
+    private expandedGroups;
+    private getItems;
+    private hideItem;
+    private showItem;
+    constructor(getItems: (ids: string[]) => ToastItem[], hideItem: (id: string) => void, showItem: (id: string) => void);
+    add(id: string, groupKey: string): void;
+    remove(id: string, groupKey: string): void;
+    toggleExpand(groupKey: string): void;
+    isExpanded(groupKey: string): boolean;
+    getGroupIds(groupKey: string): string[];
+    hasGroup(groupKey: string): boolean;
+    clear(): void;
+}
+
+export declare const isServer: boolean;
+
+export declare const PRIORITY_ORDER: Record<ToastPriority, number>;
+
+export declare interface PromiseToastMessages<T = unknown> {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((err: unknown) => string);
+}
+
+export declare const Toast: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, ReturnType<typeof __VLS_template_2>>;
+
+export declare const toast: ToastApi;
+
+export declare const TOAST_CONTEXT_KEY: unique symbol;
+
+export declare interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+
+export declare const ToastActions: DefineComponent<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_5<{
+toast: ToastItem;
+onDismiss: (id: string) => void;
+}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_5<{
+toast: ToastItem;
+onDismiss: (id: string) => void;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare type ToastApi = ReturnType<typeof buildToastApi>;
+
+declare class ToastBuffer {
+    private buffer;
+    private flushed;
+    private flushCallbacks;
+    push(message: string | VNode, options: ToastOptions): void;
+    onFlush(cb: (items: BufferedToast[]) => void): void;
+    flush(): void;
+    isFlushed(): boolean;
+    get size(): number;
+}
+
+export declare const ToastContainer: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+
+export declare interface ToastContext {
+    queue: ToastQueue;
+    addToast(message: string | VNode, options?: ToastOptions): string;
+    dismiss(id?: string): void;
+    update(id: string, options: Partial<ToastOptions>): void;
+    isActive(id: string): boolean;
+}
+
+export declare interface ToastDesignTokens {
+    colorBg?: string;
+    colorText?: string;
+    colorBorder?: string;
+    colorSuccess?: string;
+    colorError?: string;
+    colorWarning?: string;
+    colorInfo?: string;
+    colorLoading?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    lineHeight?: string;
+    borderRadius?: string;
+    borderWidth?: string;
+    shadow?: string;
+    paddingX?: string;
+    paddingY?: string;
+    iconSize?: string;
+    progressHeight?: string;
+    maxWidth?: string;
+    minWidth?: string;
+    transitionDuration?: string;
+    transitionEasing?: string;
+    zIndex?: string;
+}
+
+export declare const ToastIcon: DefineComponent<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_3<{
+type: ToastType;
+icon?: Component | string | false;
+}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_3<{
+type: ToastType;
+icon?: Component | string | false;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare interface ToastItem {
+    id: string;
+    message: string | VNode;
+    options: Required<Omit<ToastOptions, 'component' | 'componentProps' | 'icon' | 'action' | 'undo' | 'theme' | 'position'>> & {
+        position?: ToastPosition;
+        component?: Component;
+        componentProps?: Record<string, unknown>;
+        icon?: Component | string | false;
+        action?: ToastAction;
+        undo?: ToastUndo;
+        theme?: 'light' | 'dark' | 'system' | ToastDesignTokens;
+    };
+    createdAt: number;
+    remaining: Ref<number>;
+    isPaused: Ref<boolean>;
+    groupCount: Ref<number>;
+    isGrouped: Ref<boolean>;
+    pause(): void;
+    resume(): void;
+    dismiss(): void;
+    update(opts: Partial<ToastOptions>): void;
+}
+
+export declare interface ToastOptions {
+    id?: string;
+    type?: ToastType;
+    priority?: ToastPriority;
+    duration?: number;
+    position?: ToastPosition;
+    closable?: boolean;
+    groupKey?: string;
+    icon?: Component | string | false;
+    action?: ToastAction;
+    undo?: ToastUndo;
+    onClose?: () => void;
+    onAutoClose?: () => void;
+    pauseOnHover?: boolean;
+    pauseOnFocusLoss?: boolean;
+    swipeToDismiss?: boolean;
+    persist?: boolean;
+    component?: Component;
+    componentProps?: Record<string, unknown>;
+    ariaLive?: 'assertive' | 'polite';
+    theme?: 'light' | 'dark' | 'system' | ToastDesignTokens;
+}
+
+export declare type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+
+export declare type ToastPriority = 'critical' | 'high' | 'normal' | 'low';
+
+export declare const ToastProgressBar: DefineComponent<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_4<{
+remaining: number;
+}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_4<{
+remaining: number;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+
+export declare class ToastQueue {
+    active: ShallowReactive<ToastItem[]>;
+    pending: ShallowReactive<ToastItem[]>;
+    private maxVisible;
+    private hiddenItems;
+    private timers;
+    private groupManager;
+    private rateLimit;
+    private rateLimitWindowMs;
+    private recentAddTimes;
+    private persistStorage;
+    private addListeners;
+    private dismissListeners;
+    private updateListeners;
+    constructor(maxVisible?: number, options?: {
+        rateLimit?: number;
+        rateLimitWindowMs?: number;
+        persistStorage?: boolean;
+    });
+    /** Subscribe to toast add events. Returns an unsubscribe function. */
+    onAdd(fn: EventListener_2<[ToastItem]>): () => void;
+    /** Subscribe to toast dismiss events. Returns an unsubscribe function. */
+    onDismiss(fn: EventListener_2<[string]>): () => void;
+    /** Subscribe to toast update events. Returns an unsubscribe function. */
+    onUpdate(fn: EventListener_2<[string, Partial<ToastOptions>]>): () => void;
+    private emit;
+    private isRateLimited;
+    private restoreFromStorage;
+    private saveToStorage;
+    private removeFromStorage;
+    get visibleActive(): ToastItem[];
+    isHidden(id: string): boolean;
+    add(message: string | VNode, options?: ToastOptions): string;
+    remove(id: string): void;
+    update(id: string, partial: Partial<ToastOptions>): void;
+    dismiss(id?: string): void;
+    dismissAll(position?: ToastPosition): void;
+    isActive(id: string): boolean;
+    pauseAll(): void;
+    resumeAll(): void;
+    setMaxVisible(n: number): void;
+    toggleGroupExpand(groupKey: string): void;
+    isGroupExpanded(groupKey: string): boolean;
+    destroy(): void;
+    private createItem;
+    private startTimer;
+    private stopTimer;
+    private mergeOptions;
+    private findLowestPriorityIndex;
+    private sortPending;
+}
+
+export declare type ToastType = 'info' | 'success' | 'warning' | 'error' | 'loading' | 'custom';
+
+export declare interface ToastUndo {
+    label?: string;
+    onUndo: () => void | Promise<void>;
+    duration?: number;
+}
+
+export declare class UndoTimer {
+    private timerId;
+    private tickId;
+    private elapsed;
+    private startTime;
+    private _remaining;
+    private _isPaused;
+    private static readonly TICK_INTERVAL;
+    readonly duration: number;
+    readonly onExpire: () => void;
+    readonly onTick?: (remaining: number) => void;
+    constructor(duration: number, onExpire: () => void, onTick?: (remaining: number) => void);
+    get remaining(): number;
+    get isPaused(): boolean;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    private scheduleExpiry;
+    private clearExpiry;
+    private startTick;
+    private clearTick;
+}
+
+export declare function useToast(context?: ToastContext): ToastApi;
+
+export declare function useToastContext(): ToastContext;
+
+export declare function useToastState(context?: ToastContext): {
+    active: ComputedRef<ToastItem[]>;
+    pending: ComputedRef<ToastItem[]>;
+    count: ComputedRef<number>;
+    has: (id: string) => boolean;
+};
+
+export declare const VueToastPlugin: Plugin_2<VueToastPluginOptions | void>;
+
+export declare interface VueToastPluginOptions extends GlobalToastOptions {
+    registerComponent?: boolean;
+}
+
+export { }