@soft-toast/vue 1.0.1 → 1.1.0

package/src/composables/{useToast.test.ts → useSoftToast.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'bun:test'
-import { useToast, toast } from './useToast'
+import { useSoftToast, softToast } from './useSoftToast'
 import { toastStore } from '../stores/toastStore'
 
 // Reset store state before each test
@@ -7,11 +7,11 @@ beforeEach(() => {
   toastStore.clearAll()
 })
 
-// ─── useToast() composable ────────────────────────────────────────────────────
+// ─── useSoftToast() composable ────────────────────────────────────────────────────
 
-describe('useToast()', () => {
+describe('useSoftToast()', () => {
   it('returns an object with all API methods', () => {
-    const t = useToast()
+    const t = useSoftToast()
     expect(typeof t.default).toBe('function')
     expect(typeof t.success).toBe('function')
     expect(typeof t.error).toBe('function')
@@ -27,7 +27,7 @@ describe('useToast()', () => {
   })
 
   it('default() adds a toast with type "default"', () => {
-    const t = useToast()
+    const t = useSoftToast()
     const id = t.default('Hello')
     const toasts = toastStore.toasts.value
     expect(toasts.length).toBe(1)
@@ -37,32 +37,32 @@ describe('useToast()', () => {
   })
 
   it('success() adds a toast with type "success"', () => {
-    const t = useToast()
+    const t = useSoftToast()
     t.success('Done!')
     expect(toastStore.toasts.value[0].type).toBe('success')
     expect(toastStore.toasts.value[0].title).toBe('Done!')
   })
 
   it('error() adds a toast with type "error"', () => {
-    const t = useToast()
+    const t = useSoftToast()
     t.error('Oops!')
     expect(toastStore.toasts.value[0].type).toBe('error')
   })
 
   it('warning() adds a toast with type "warning"', () => {
-    const t = useToast()
+    const t = useSoftToast()
     t.warning('Watch out!')
     expect(toastStore.toasts.value[0].type).toBe('warning')
   })
 
   it('info() adds a toast with type "info"', () => {
-    const t = useToast()
+    const t = useSoftToast()
     t.info('FYI')
     expect(toastStore.toasts.value[0].type).toBe('info')
   })
 
   it('custom() passes options through directly', () => {
-    const t = useToast()
+    const t = useSoftToast()
     t.custom({ type: 'success', title: 'Custom', description: 'My desc', duration: 9999 })
     const added = toastStore.toasts.value[0]
     expect(added.title).toBe('Custom')
@@ -71,7 +71,7 @@ describe('useToast()', () => {
   })
 
   it('update() changes an existing toast', () => {
-    const t = useToast()
+    const t = useSoftToast()
     const id = t.default('Before')
     t.update(id, { title: 'After', type: 'success' })
     const updated = toastStore.toasts.value.find(x => x.id === id)
@@ -80,7 +80,7 @@ describe('useToast()', () => {
   })
 
   it('dismiss() marks toast as isLeaving', () => {
-    const t = useToast()
+    const t = useSoftToast()
     const id = t.default('Bye')
     t.dismiss(id)
     const toast = toastStore.toasts.value.find(x => x.id === id)
@@ -88,7 +88,7 @@ describe('useToast()', () => {
   })
 
   it('pause() and resume() toggle isPaused', () => {
-    const t = useToast()
+    const t = useSoftToast()
     const id = t.default('Pausing')
     t.pause(id)
     expect(toastStore.toasts.value[0].isPaused).toBe(true)
@@ -97,7 +97,7 @@ describe('useToast()', () => {
   })
 
   it('forward options like duration, description, position', () => {
-    const t = useToast()
+    const t = useSoftToast()
     t.success('With opts', {
       description: 'More info',
       duration: 1234,
@@ -110,75 +110,75 @@ describe('useToast()', () => {
   })
 })
 
-// ─── toast (static object) ────────────────────────────────────────────────────
+// ─── softToast (static object) ────────────────────────────────────────────────
 
-describe('toast (static API)', () => {
-  it('toast.success() adds a success toast', () => {
-    toast.success('Static success')
+describe('softToast (static API)', () => {
+  it('softToast.success() adds a success toast', () => {
+    softToast.success('Static success')
     expect(toastStore.toasts.value[0].type).toBe('success')
     expect(toastStore.toasts.value[0].title).toBe('Static success')
   })
 
-  it('toast.error() adds an error toast', () => {
-    toast.error('Static error')
+  it('softToast.error() adds an error toast', () => {
+    softToast.error('Static error')
     expect(toastStore.toasts.value[0].type).toBe('error')
   })
 
-  it('toast.warning() adds a warning toast', () => {
-    toast.warning('Careful')
+  it('softToast.warning() adds a warning toast', () => {
+    softToast.warning('Careful')
     expect(toastStore.toasts.value[0].type).toBe('warning')
   })
 
-  it('toast.info() adds an info toast', () => {
-    toast.info('Just so you know')
+  it('softToast.info() adds an info toast', () => {
+    softToast.info('Just so you know')
     expect(toastStore.toasts.value[0].type).toBe('info')
   })
 
-  it('toast.default() adds a default toast', () => {
-    toast.default('Hello world')
+  it('softToast.default() adds a default toast', () => {
+    softToast.default('Hello world')
     expect(toastStore.toasts.value[0].type).toBe('default')
   })
 
-  it('toast.custom() adds toast with arbitrary options', () => {
-    toast.custom({ title: 'Custom static', type: 'info', id: 'static-1' })
+  it('softToast.custom() adds toast with arbitrary options', () => {
+    softToast.custom({ title: 'Custom static', type: 'info', id: 'static-1' })
     expect(toastStore.toasts.value[0].id).toBe('static-1')
     expect(toastStore.toasts.value[0].title).toBe('Custom static')
   })
 
-  it('toast.update() modifies a toast', () => {
-    const id = toast.default('Initial')
-    toast.update(id, { title: 'Updated' })
+  it('softToast.update() modifies a toast', () => {
+    const id = softToast.default('Initial')
+    softToast.update(id, { title: 'Updated' })
     expect(toastStore.toasts.value.find(x => x.id === id)?.title).toBe('Updated')
   })
 
-  it('toast.pause() and toast.resume() work', () => {
-    const id = toast.info('Pausable')
-    toast.pause(id)
+  it('softToast.pause() and softToast.resume() work', () => {
+    const id = softToast.info('Pausable')
+    softToast.pause(id)
     expect(toastStore.toasts.value[0].isPaused).toBe(true)
-    toast.resume(id)
+    softToast.resume(id)
     expect(toastStore.toasts.value[0].isPaused).toBe(false)
   })
 
-  it('toast.dismiss() marks toast as leaving', () => {
-    const id = toast.success('Going away')
-    toast.dismiss(id)
+  it('softToast.dismiss() marks toast as leaving', () => {
+    const id = softToast.success('Going away')
+    softToast.dismiss(id)
     expect(toastStore.toasts.value.find(x => x.id === id)?.isLeaving).toBe(true)
   })
 
   it('multiple toasts are ordered newest-first', () => {
-    toast.default('First')
-    toast.success('Second')
-    toast.error('Third')
+    softToast.default('First')
+    softToast.success('Second')
+    softToast.error('Third')
     const titles = toastStore.toasts.value.map(t => t.title)
     expect(titles).toEqual(['Third', 'Second', 'First'])
   })
 })
 
-// ─── toast.promise() ─────────────────────────────────────────────────────────
+// ─── softToast.promise() ─────────────────────────────────────────────────────────
 
-describe('toast.promise()', () => {
+describe('softToast.promise()', () => {
   it('resolves: updates toast to success', async () => {
-    const id = await toast.promise(
+    const id = await softToast.promise(
       Promise.resolve('ok'),
       { loading: 'Loading…', success: 'Done!', error: 'Failed' }
     )
@@ -191,7 +191,7 @@ describe('toast.promise()', () => {
   it('rejects: updates toast to error and re-throws', async () => {
     let caught: unknown
     try {
-      await toast.promise(
+      await softToast.promise(
         Promise.reject(new Error('boom')),
         { loading: 'Loading…', success: 'Done!', error: 'Something failed' }
       )
@@ -206,25 +206,25 @@ describe('toast.promise()', () => {
 
 // ─── Flash & sound API surface ────────────────────────────────────────────────
 
-describe('useToast() — flash API methods', () => {
+describe('useSoftToast() — flash API methods', () => {
   it('returns flash, showFlashes, hasFlashes methods', () => {
-    const t = useToast()
+    const t = useSoftToast()
     expect(typeof t.flash).toBe('function')
     expect(typeof t.showFlashes).toBe('function')
     expect(typeof t.hasFlashes).toBe('function')
   })
 })
 
-describe('toast (static) — flash API methods', () => {
-  it('toast.flash is a function', () => {
-    expect(typeof toast.flash).toBe('function')
+describe('softToast (static) — flash API methods', () => {
+  it('softToast.flash is a function', () => {
+    expect(typeof softToast.flash).toBe('function')
   })
 
-  it('toast.showFlashes is a function', () => {
-    expect(typeof toast.showFlashes).toBe('function')
+  it('softToast.showFlashes is a function', () => {
+    expect(typeof softToast.showFlashes).toBe('function')
   })
 
-  it('toast.hasFlashes is a function', () => {
-    expect(typeof toast.hasFlashes).toBe('function')
+  it('softToast.hasFlashes is a function', () => {
+    expect(typeof softToast.hasFlashes).toBe('function')
   })
 })

package/src/composables/{useToast.ts → useSoftToast.ts}

@@ -4,7 +4,7 @@ import { queueFlash, consumeFlashes, hasPendingFlashes } from './useFlash'
 
 // ─── Composable API ───────────────────────────────────────────────────────────
 
-export const useToast = () => ({
+export const useSoftToast = () => ({
   default: (title: string, options?: Omit<ToastOptions, 'type' | 'title'>) =>
     toastStore.add({ ...options, type: 'default', title }),
 
@@ -25,7 +25,7 @@ export const useToast = () => ({
 
   promise: <T>(
     promiseFn: Promise<T>,
-    messages: ToastPromiseMessages,
+    messages: ToastPromiseMessages<T>,
     options?: Omit<ToastOptions, 'type' | 'promise' | 'promiseMessages'>
   ): Promise<T> => toastStore.promise(promiseFn, messages, options),
 
@@ -44,7 +44,7 @@ export const useToast = () => ({
    * Perfect for the "submit → redirect → show success" pattern.
    *
    * @example
-   * const { flash } = useToast()
+   * const { flash } = useSoftToast()
    * await api.save()
    * flash('Saved!', { type: 'success' })
    * router.push('/dashboard')
@@ -64,7 +64,7 @@ export const useToast = () => ({
 
 // ─── Singleton API (usable outside components) ────────────────────────────────
 
-export const toast = {
+export const softToast = {
   default: (title: string, options?: Omit<ToastOptions, 'type' | 'title'>) =>
     toastStore.add({ ...options, type: 'default', title }),
   success: (title: string, options?: Omit<ToastOptions, 'type' | 'title'>) =>
@@ -79,7 +79,7 @@ export const toast = {
     toastStore.loading(title, options),
   promise: <T>(
     promiseFn: Promise<T>,
-    messages: ToastPromiseMessages,
+    messages: ToastPromiseMessages<T>,
     options?: Omit<ToastOptions, 'type' | 'promise' | 'promiseMessages'>
   ): Promise<T> => toastStore.promise(promiseFn, messages, options),
   custom: (options: ToastOptions) => toastStore.add(options),

package/src/exports.test.ts

@@ -4,6 +4,23 @@ import { describe, it, expect } from 'bun:test'
 // This acts as a "contract test" — if something is accidentally removed, CI will catch it.
 
 describe('Package exports', () => {
+  it('exports the expected public API', async () => {
+    const api = await import('./index')
+    expect(Object.keys(api).sort()).toEqual([
+      'SoftToastPlugin',
+      'ToastContainer',
+      'ToastItem',
+      'consumeFlashes',
+      'getToastOptions',
+      'hasPendingFlashes',
+      'queueFlash',
+      'softToast',
+      'toastStore',
+      'useFlash',
+      'useSoftToast',
+    ])
+  })
+
   it('exports SoftToastPlugin with install()', async () => {
     const { SoftToastPlugin } = await import('./index')
     expect(SoftToastPlugin).toBeDefined()
@@ -20,33 +37,33 @@ describe('Package exports', () => {
     expect(opts).toHaveProperty('theme')
   })
 
-  it('exports useToast()', async () => {
-    const { useToast } = await import('./index')
-    expect(typeof useToast).toBe('function')
-    const api = useToast()
+  it('exports useSoftToast()', async () => {
+    const { useSoftToast } = await import('./index')
+    expect(typeof useSoftToast).toBe('function')
+    const api = useSoftToast()
     expect(typeof api.success).toBe('function')
     expect(typeof api.error).toBe('function')
   })
 
-  it('exports toast object', async () => {
-    const { toast } = await import('./index')
-    expect(toast).toBeDefined()
-    expect(typeof toast.success).toBe('function')
-    expect(typeof toast.error).toBe('function')
-    expect(typeof toast.warning).toBe('function')
-    expect(typeof toast.info).toBe('function')
-    expect(typeof toast.default).toBe('function')
-    expect(typeof toast.promise).toBe('function')
-    expect(typeof toast.custom).toBe('function')
-    expect(typeof toast.update).toBe('function')
-    expect(typeof toast.dismiss).toBe('function')
-    expect(typeof toast.dismissAll).toBe('function')
-    expect(typeof toast.pause).toBe('function')
-    expect(typeof toast.resume).toBe('function')
+  it('exports softToast object', async () => {
+    const { softToast } = await import('./index')
+    expect(softToast).toBeDefined()
+    expect(typeof softToast.success).toBe('function')
+    expect(typeof softToast.error).toBe('function')
+    expect(typeof softToast.warning).toBe('function')
+    expect(typeof softToast.info).toBe('function')
+    expect(typeof softToast.default).toBe('function')
+    expect(typeof softToast.promise).toBe('function')
+    expect(typeof softToast.custom).toBe('function')
+    expect(typeof softToast.update).toBe('function')
+    expect(typeof softToast.dismiss).toBe('function')
+    expect(typeof softToast.dismissAll).toBe('function')
+    expect(typeof softToast.pause).toBe('function')
+    expect(typeof softToast.resume).toBe('function')
     // Flash & sound API
-    expect(typeof toast.flash).toBe('function')
-    expect(typeof toast.showFlashes).toBe('function')
-    expect(typeof toast.hasFlashes).toBe('function')
+    expect(typeof softToast.flash).toBe('function')
+    expect(typeof softToast.showFlashes).toBe('function')
+    expect(typeof softToast.hasFlashes).toBe('function')
   })
 
   it('exports toastStore with all methods', async () => {

package/src/index.ts

@@ -1,6 +1,6 @@
 // Main exports
 export { SoftToastPlugin, getToastOptions } from './plugin'
-export { useToast, toast } from './composables/useToast'
+export { useSoftToast, softToast } from './composables/useSoftToast'
 export { useFlash, queueFlash, consumeFlashes, hasPendingFlashes } from './composables/useFlash'
 export { toastStore } from './stores/toastStore'
 
@@ -22,4 +22,3 @@ export type {
   AnimationPreset,
   QueueOverflow
 } from './types'
-

package/src/plugin.ts

@@ -19,7 +19,8 @@ let pluginOptions: ToastPluginOptions = {
   queueOverflow: 'drop-oldest',
   dir: 'ltr',
   swipeToDismiss: true,
-  teleportTarget: 'body'
+  teleportTarget: 'body',
+  autoMount: true
 }
 
 // Flag to check if container is mounted
@@ -30,8 +31,10 @@ export const SoftToastPlugin = {
     // Merge options
     pluginOptions = { ...pluginOptions, ...options }
     
+    app.component('SoftToastContainer', ToastContainer)
+
     // Only mount container once
-    if (!isContainerMounted && typeof window !== 'undefined') {
+    if (pluginOptions.autoMount !== false && !isContainerMounted && typeof window !== 'undefined') {
       // Create a container div
       const containerId = 'soft-toast-global-container'
       let container = document.getElementById(containerId)
@@ -42,9 +45,6 @@ export const SoftToastPlugin = {
         document.body.appendChild(container)
       }
       
-      // Mount ToastContainer
-      app.component('SoftToastContainer', ToastContainer)
-      
       // Create a mini-app instance just for the toast container
       const toastContainerApp = createApp({
         render: () => h(ToastContainer, {
@@ -62,7 +62,9 @@ export const SoftToastPlugin = {
           maxQueue: pluginOptions.maxQueue,
           queueOverflow: pluginOptions.queueOverflow,
           dir: pluginOptions.dir,
-          swipeToDismiss: pluginOptions.swipeToDismiss
+          swipeToDismiss: pluginOptions.swipeToDismiss,
+          showTimestamp: pluginOptions.showTimestamp,
+          slotFilter: pluginOptions.slotFilter
         })
       })
       

package/src/stores/toastStore.ts

@@ -26,6 +26,17 @@ const defaultOptions: Required<Pick<
 
 const toasts = ref<Toast[]>([])
 
+// Non-reactive timer state — lives outside Vue reactivity to avoid per-frame re-renders
+const timerMap = new Map<string, { remainingTime: number; isPaused: boolean }>()
+
+const resetTimer = (id: string, duration: number, isPaused = false) => {
+  if (duration === Infinity) {
+    timerMap.delete(id)
+    return
+  }
+  timerMap.set(id, { remainingTime: duration, isPaused })
+}
+
 // ─── Computed ─────────────────────────────────────────────────────────────────
 
 const getToastsByPosition = (position: ToastPosition) =>
@@ -37,7 +48,7 @@ const allToasts = computed(() => toasts.value)
 
 /**
  * Add a toast — or UPDATE an existing one if the same `id` is already visible.
- * This automatic deduplication means calling toast.error('Oops', { id: 'network-error' })
+ * This automatic deduplication means calling softToast.error('Oops', { id: 'network-error' })
  * five times in a row results in ONE toast that refreshes its content each time.
  */
 const add = (options: ToastOptions): string => {
@@ -57,6 +68,7 @@ const add = (options: ToastOptions): string => {
       isPaused: existing.isPaused,
       isLeaving: false,
     }
+    resetTimer(id, options.duration ?? existing.duration, existing.isPaused)
     // Play sound again if configured (content changed)
     const sound = options.sound
     const vol = options.soundVolume ?? 0.5
@@ -65,12 +77,13 @@ const add = (options: ToastOptions): string => {
   }
 
   // ── New toast ──
+  const duration = options.duration ?? defaultOptions.duration
   const toast: Toast = {
     ...defaultOptions,
     ...options,
     id,
     createdAt: Date.now(),
-    remainingTime: options.duration ?? defaultOptions.duration,
+    remainingTime: duration,
     isPaused: false,
     isExpanded: true,
     isLeaving: false,
@@ -81,6 +94,9 @@ const add = (options: ToastOptions): string => {
     showProgress: options.showProgress ?? defaultOptions.showProgress,
   }
 
+  // Register in non-reactive timer map
+  resetTimer(id, duration, false)
+
   toasts.value.unshift(toast)
   startTickLoop()
 
@@ -95,13 +111,25 @@ const add = (options: ToastOptions): string => {
 const update = (id: string, options: Partial<ToastOptions>) => {
   const index = toasts.value.findIndex((t) => t.id === id)
   if (index !== -1) {
-    toasts.value[index] = { ...toasts.value[index], ...options }
+    const existing = toasts.value[index]
+    const nextDuration = options.duration ?? existing.duration
+    const nextRemainingTime =
+      options.duration === undefined ? existing.remainingTime : nextDuration
+    toasts.value[index] = {
+      ...existing,
+      ...options,
+      remainingTime: nextRemainingTime,
+    }
+    if (options.duration !== undefined) {
+      resetTimer(id, nextDuration, existing.isPaused)
+    }
   }
 }
 
 const dismiss = (id?: string | { type?: ToastType | ToastType[] }) => {
   if (!id) {
     toasts.value.forEach((t) => { t.isLeaving = true })
+    timerMap.clear()
     setTimeout(() => { toasts.value = [] }, 400)
     return
   }
@@ -111,6 +139,7 @@ const dismiss = (id?: string | { type?: ToastType | ToastType[] }) => {
     if (toast) {
       toast.isLeaving = true
       toast.onDismiss?.(id)
+      timerMap.delete(id)
       setTimeout(() => {
         toasts.value = toasts.value.filter((t) => t.id !== id)
       }, 400)
@@ -121,6 +150,7 @@ const dismiss = (id?: string | { type?: ToastType | ToastType[] }) => {
       if (types.includes(t.type)) {
         t.isLeaving = true
         t.onDismiss?.(t.id)
+        timerMap.delete(t.id)
       }
     })
     setTimeout(() => {
@@ -130,11 +160,15 @@ const dismiss = (id?: string | { type?: ToastType | ToastType[] }) => {
 }
 
 const pause = (id: string) => {
+  const timer = timerMap.get(id)
+  if (timer) timer.isPaused = true
   const toast = toasts.value.find((t) => t.id === id)
   if (toast) toast.isPaused = true
 }
 
 const resume = (id: string) => {
+  const timer = timerMap.get(id)
+  if (timer) timer.isPaused = false
   const toast = toasts.value.find((t) => t.id === id)
   if (toast) toast.isPaused = false
 }
@@ -163,19 +197,31 @@ const startTickLoop = () => {
     const delta = currentTime - lastTime
     lastTime = currentTime
 
-    toasts.value.forEach((toast) => {
-      if (!toast.isPaused && !toast.isLeaving && toast.remainingTime > 0 && toast.duration !== Infinity) {
-        toast.remainingTime -= delta
-        if (toast.remainingTime <= 0) {
-          toast.isLeaving = true
-          toast.onAutoClose?.(toast.id)
-          setTimeout(() => {
-            toasts.value = toasts.value.filter((t) => t.id !== toast.id)
-          }, 400)
-        }
-      }
+    // Tick non-reactive timer map — zero Vue reactivity cost per frame
+    const expiredIds: string[] = []
+    timerMap.forEach((timer, id) => {
+      if (timer.isPaused) return
+      const toast = toasts.value.find((t) => t.id === id)
+      if (!toast || toast.isLeaving || toast.duration === Infinity) return
+      timer.remainingTime -= delta
+      // Sync remainingTime back to toast only for progress bar consumers
+      if (toast.showProgress) toast.remainingTime = timer.remainingTime
+      if (timer.remainingTime <= 0) expiredIds.push(id)
     })
 
+    // Mutate Vue state only when a toast actually expires
+    for (const id of expiredIds) {
+      timerMap.delete(id)
+      const toast = toasts.value.find((t) => t.id === id)
+      if (toast && !toast.isLeaving) {
+        toast.isLeaving = true
+        toast.onAutoClose?.(id)
+        setTimeout(() => {
+          toasts.value = toasts.value.filter((t) => t.id !== id)
+        }, 400)
+      }
+    }
+
     if (toasts.value.length > 0) {
       rafId = requestAnimationFrame(loop)
     } else {
@@ -206,7 +252,7 @@ const loading = (title: string, options?: Omit<ToastOptions, 'type' | 'title'>)
 
 const promise = async <T>(
   promiseFn: Promise<T>,
-  messages: ToastPromiseMessages,
+  messages: ToastPromiseMessages<T>,
   options?: Omit<ToastOptions, 'type' | 'promise' | 'promiseMessages'>
 ): Promise<T> => {
   const id = add({
@@ -220,16 +266,16 @@ const promise = async <T>(
     const result = await promiseFn
     update(id, {
       type: 'success',
-      title: messages.success,
-      description: messages.description?.success,
+      title: typeof messages.success === 'function' ? messages.success(result) : messages.success,
+      description: typeof messages.description?.success === 'function' ? messages.description.success(result) : messages.description?.success,
       duration: 4000,
     })
     return result
   } catch (err) {
     update(id, {
       type: 'error',
-      title: messages.error,
-      description: messages.description?.error,
+      title: typeof messages.error === 'function' ? messages.error(err) : messages.error,
+      description: typeof messages.description?.error === 'function' ? messages.description.error(err) : messages.description?.error,
       action: messages.action?.error,
       duration: 6000,
     })
@@ -237,9 +283,13 @@ const promise = async <T>(
   }
 }
 
-const clearAll = () => { toasts.value = [] }
+const clearAll = () => {
+  timerMap.clear()
+  toasts.value = []
+}
 
 const remove = (id: string) => {
+  timerMap.delete(id)
   toasts.value = toasts.value.filter((t) => t.id !== id)
 }
 
@@ -262,7 +312,7 @@ export interface ToastStore {
   warning: (title: string, options?: Omit<ToastOptions, 'type' | 'title'>) => string
   info: (title: string, options?: Omit<ToastOptions, 'type' | 'title'>) => string
   loading: (title: string, options?: Omit<ToastOptions, 'type' | 'title'>) => string
-  promise: <T>(promiseFn: Promise<T>, messages: ToastPromiseMessages, options?: Omit<ToastOptions, 'type' | 'promise' | 'promiseMessages'>) => Promise<T>
+  promise: <T>(promiseFn: Promise<T>, messages: ToastPromiseMessages<T>, options?: Omit<ToastOptions, 'type' | 'promise' | 'promiseMessages'>) => Promise<T>
   clearAll: () => void
   remove: (id: string) => void
 }