@effect-app/vue 4.0.0-beta.99 → 4.0.0

package/src/queryLifetime.ts

@@ -0,0 +1,74 @@
+import type * as AsyncResult from "effect/reactivity/AsyncResult"
+import * as Atom from "effect/reactivity/Atom"
+
+/**
+ * Per-query observer count + invalidation flag. Lives on the family atom so
+ * invalidate can mark stale and refetch only when someone is looking
+ * (TanStack refetchType: "active").
+ */
+export interface QueryLifetime {
+  observers: number
+  invalidated: boolean
+}
+
+const lifetimes = new WeakMap<Atom.Atom<any>, QueryLifetime>()
+
+const rootOf = (atom: Atom.Atom<any>): Atom.Atom<any> => {
+  let target = atom
+  while (target.initialValueTarget !== undefined) {
+    target = target.initialValueTarget
+  }
+  return target
+}
+
+export const queryLifetimeOf = (atom: Atom.Atom<any>): QueryLifetime | undefined =>
+  lifetimes.get(rootOf(atom)) ?? lifetimes.get(atom)
+
+export const attachQueryLifetime = <A, E>(
+  atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>
+): QueryLifetime => {
+  const existing = queryLifetimeOf(atom)
+  if (existing !== undefined) return existing
+  const created: QueryLifetime = { observers: 0, invalidated: false }
+  lifetimes.set(rootOf(atom), created)
+  lifetimes.set(atom, created)
+  return created
+}
+
+/**
+ * Count this subscription as an observer of `family`. On remount, consume a
+ * pending invalidation and refresh the family atom.
+ */
+export const observeQueryAtom = <A, E>(
+  family: Atom.Atom<AsyncResult.AsyncResult<A, E>>
+): Atom.Atom<AsyncResult.AsyncResult<A, E>> => {
+  const life = attachQueryLifetime(family)
+  return Atom.transform(family, (get) => {
+    life.observers++
+    get.addFinalizer(() => {
+      life.observers = Math.max(0, life.observers - 1)
+    })
+    if (life.invalidated) {
+      life.invalidated = false
+      get.refresh(family)
+    }
+    return get(family)
+  }, { initialValueTarget: family })
+}
+
+/**
+ * Idle queries with a lifetime are marked stale. Queries that still have
+ * observers (or have no lifetime, e.g. ad-hoc registry mounts of a raw
+ * effect atom) are refetched now.
+ */
+export const atomsToRefetch = <A, E>(
+  atoms: ReadonlyArray<Atom.Atom<AsyncResult.AsyncResult<A, E>>>
+): ReadonlyArray<Atom.Atom<AsyncResult.AsyncResult<A, E>>> => {
+  const active: Array<Atom.Atom<AsyncResult.AsyncResult<A, E>>> = []
+  for (const atom of atoms) {
+    const life = queryLifetimeOf(atom)
+    if (life === undefined || life.observers > 0) active.push(atom)
+    else life.invalidated = true
+  }
+  return active
+}

package/src/routeParams.ts

@@ -1,7 +1,7 @@
-import { flow } from "effect"
-import { Option, S } from "effect-app"
-import type { Schema } from "effect-app/Schema"
+import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
 import { typedKeysOf } from "effect-app/utils"
+import { flow } from "effect/Function"
 import type { ParsedQuery } from "query-string"
 
 export function getQueryParam(search: ParsedQuery, param: string) {
@@ -16,7 +16,7 @@ export const getQueryParamO = flow(getQueryParam, Option.fromNullishOr)
 
 export function parseRouteParamsOption<NER extends Record<string, S.Codec<any, any>>>(query: Record<string, any>, t: NER // enforce non empty
 ): {
-  [K in keyof NER]: Option.Option<Schema.Type<NER[K]>>
+  [K in keyof NER]: Option.Option<NER[K]["Type"]>
 } {
   return typedKeysOf(t).reduce(
     (prev, cur) => {
@@ -28,7 +28,7 @@ export function parseRouteParamsOption<NER extends Record<string, S.Codec<any, a
       return prev
     },
     {} as {
-      [K in keyof NER]: Option.Option<Schema.Type<NER[K]>>
+      [K in keyof NER]: Option.Option<NER[K]["Type"]>
     }
   )
 }
@@ -37,7 +37,7 @@ export function parseRouteParams<NER extends Record<string, S.Codec<any, any>>>(
   query: Record<string, any>,
   t: NER // enforce non empty
 ): {
-  [K in keyof NER]: Schema.Type<NER[K]>
+  [K in keyof NER]: NER[K]["Type"]
 } {
   return typedKeysOf(t).reduce(
     (prev, cur) => {
@@ -49,7 +49,7 @@ export function parseRouteParams<NER extends Record<string, S.Codec<any, any>>>(
       return prev
     },
     {} as {
-      [K in keyof NER]: Schema.Type<NER[K]>
+      [K in keyof NER]: NER[K]["Type"]
     }
   )
 }

package/src/runtime.ts

@@ -1,54 +1 @@
-import { Exit, flow, ManagedRuntime } from "effect"
-import { Effect, Layer, Logger } from "effect-app"
-import { CauseException } from "effect-app/client/errors"
-import { type Context } from "effect-app/Context"
-
-export function makeAppRuntime<A, E>(layer: Layer.Layer<A, E>) {
-  return Effect.gen(function*() {
-    const l = layer.pipe(
-      Layer.provide(Logger.layer([Logger.consolePretty()]))
-    ) as Layer.Layer<A, never>
-    const mrt = ManagedRuntime.make(l)
-    yield* mrt.contextEffect
-    return Object.assign(mrt, {
-      [Symbol.dispose]() {
-        return Effect.runSync(mrt.disposeEffect)
-      },
-
-      [Symbol.asyncDispose]() {
-        return mrt.dispose()
-      }
-    }) // as we initialise here, there is no more error left.
-  })
-}
-
-export function initializeSync<A, E>(layer: Layer.Layer<A, E, never>) {
-  const runtime = Effect.runSync(makeAppRuntime(layer))
-  return runtime
-}
-
-export function initializeAsync<A, E>(layer: Layer.Layer<A, E, never>) {
-  return Effect
-    .runPromise(makeAppRuntime(layer))
-}
-
-// we wrap into CauseException because we want to keep the full cause of the failure.
-export const makeRunPromise = <T>(services: Context<T>) =>
-  flow(Effect.runPromiseExitWith(services), (_) =>
-    _.then(
-      Exit.match({
-        onFailure: (cause) => Promise.reject(new CauseException(cause, "runPromise")),
-        onSuccess: (value) => Promise.resolve(value)
-      })
-    ))
-
-export const makeRunSync = <T>(services: Context<T>) =>
-  flow(
-    Effect.runSyncExitWith(services),
-    Exit.match({
-      onFailure: (cause) => {
-        throw new CauseException(cause, "runSync")
-      },
-      onSuccess: (value) => value
-    })
-  )
+export * from "effect-app/runtime"

package/src/suspense.ts

@@ -0,0 +1,43 @@
+import { Effect } from "effect-app"
+import * as AsyncResult from "effect/reactivity/AsyncResult"
+import { computed, type ComputedRef, nextTick } from "vue"
+
+/**
+ * The always-defined `data` ref behind a resolved suspense query.
+ *
+ * A reactive arg can re-point the view at a DIFFERENT cache atom after the suspense promise
+ * resolved; the fresh atom starts `Initial` (no `previousSuccess` carried over), so the raw data
+ * briefly reads `undefined` while it fetches. The suspense contract ("after the await there is
+ * always a value") is kept by serving the last defined value across that transition — TanStack's
+ * keepPreviousData, which Vue needs because it cannot re-suspend after mount. Waiting/failure of
+ * the new fetch stays observable on the view's `result` ref.
+ *
+ * Throws only if there has never been a value, which is unreachable once the suspense await
+ * resolved successfully.
+ */
+export const latestDefined = <TData>(source: () => TData | undefined, label: string): ComputedRef<TData> => {
+  let last: TData | undefined
+  return computed<TData>(() => {
+    const latest = source()
+    if (latest !== undefined) {
+      last = latest
+      return latest
+    }
+    if (last !== undefined) return last
+    throw new Error(`Internal Error: ${label} resolved without a latest value`)
+  })
+}
+
+export const awaitResolvedSuspenseResult = <A, E>(
+  resultRef: ComputedRef<AsyncResult.AsyncResult<A, E>>
+) =>
+  Effect.gen(function*() {
+    let result = resultRef.value
+
+    for (let remainingTicks = 3; remainingTicks > 0 && AsyncResult.isInitial(result); remainingTicks--) {
+      yield* Effect.promise(() => nextTick())
+      result = resultRef.value
+    }
+
+    return result
+  })

package/src/toast.ts

@@ -1,52 +1 @@
-import { Context, Effect, Option } from "effect-app"
-import { accessEffectFn } from "effect-app/Context"
-
-export type ToastId = string | number
-export type ToastOpts = { id?: ToastId; timeout?: number }
-export type ToastOptsInternal = { id?: ToastId | null; timeout?: number }
-
-export type UseToast = () => {
-  error: (this: void, message: string, options?: ToastOpts) => ToastId
-  warning: (this: void, message: string, options?: ToastOpts) => ToastId
-  success: (this: void, message: string, options?: ToastOpts) => ToastId
-  info: (this: void, message: string, options?: ToastOpts) => ToastId
-  dismiss: (this: void, id: ToastId) => void
-}
-
-export class CurrentToastId extends Context.Opaque<CurrentToastId, { toastId: ToastId }>()("CurrentToastId") {}
-
-/** fallback to CurrentToastId when available unless id is explicitly set to a value or null */
-export const wrap = (toast: ReturnType<UseToast>) => {
-  const wrap = (toastHandler: (message: string, options?: ToastOpts) => ToastId) => {
-    return (message: string, options?: ToastOptsInternal) =>
-      Effect.serviceOption(CurrentToastId).pipe(
-        Effect.flatMap((currentToast) =>
-          Effect.sync(() => {
-            const { id: _id, ...rest } = options ?? {}
-            const id = _id !== undefined
-              ? _id ?? undefined
-              : Option.getOrUndefined(Option.map(currentToast, (_) => _.toastId))
-            // when id is undefined, we may end up with no toast at all..
-            return toastHandler(message, id !== undefined ? { ...rest, id } : rest)
-          })
-        )
-      )
-  }
-  return {
-    error: wrap(toast.error),
-    info: wrap(toast.info),
-    success: wrap(toast.success),
-    warning: wrap(toast.warning),
-    dismiss: (toastId: ToastId) => Effect.sync(() => toast.dismiss(toastId))
-  }
-}
-
-type ToastShape = ReturnType<typeof wrap>
-
-export class Toast extends Context.Opaque<Toast, ToastShape>()("Toast") {
-  static readonly error = accessEffectFn(this, "error")
-  static readonly info = accessEffectFn(this, "info")
-  static readonly success = accessEffectFn(this, "success")
-  static readonly warning = accessEffectFn(this, "warning")
-  static readonly dismiss = accessEffectFn(this, "dismiss")
-}
+export * from "effect-app/toast"

package/src/withToast.ts

@@ -1,99 +1 @@
-import { Cause, Context, Effect, Layer, type Option } from "effect-app"
-import { wrapEffect } from "effect-app/utils"
-import { CurrentToastId, Toast } from "./toast.js"
-
-export interface ToastOptions<A, E, Args extends ReadonlyArray<unknown>, WaiR, SucR, ErrR> {
-  stableToastId?: undefined | string | ((...args: Args) => string | undefined)
-  timeout?: number
-  onWaiting:
-    | string
-    | ((...args: Args) => string | null)
-    | null
-    | ((
-      ...args: Args
-    ) => Effect.Effect<string | null, never, WaiR>)
-  onSuccess:
-    | string
-    | ((a: A, ...args: Args) => string | null)
-    | null
-    | ((
-      a: A,
-      ...args: Args
-    ) => Effect.Effect<string | null, never, SucR>)
-  onFailure:
-    | string
-    | ((
-      error: Option.Option<E>,
-      ...args: Args
-    ) => string | { level: "warn" | "error"; message: string })
-    | ((
-      error: Option.Option<E>,
-      ...args: Args
-    ) => Effect.Effect<string | { level: "warn" | "error"; message: string }, never, ErrR>)
-}
-
-// @effect-diagnostics-next-line missingEffectServiceDependency:off
-export class WithToast extends Context.Service<WithToast>()("WithToast", {
-  make: Effect.gen(function*() {
-    const toast = yield* Toast
-    return <A, E, Args extends readonly unknown[], R, WaiR = never, SucR = never, ErrR = never>(
-      options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
-    ) =>
-      Effect.fnUntraced(function*(self: Effect.Effect<A, E, R>, ...args: Args) {
-        const baseTimeout = options.timeout ?? 3_000
-
-        const stableToastId = typeof options.stableToastId === "function"
-          ? options.stableToastId(...args)
-          : options.stableToastId
-
-        const t = yield* wrapEffect(options.onWaiting)(...args)
-        const toastId = t === null ? stableToastId : yield* toast.info(
-          t,
-          { id: stableToastId ?? null } // TODO: timeout forever?
-        )
-        return yield* self.pipe(
-          Effect.tap(Effect.fnUntraced(function*(a) {
-            const t = yield* wrapEffect(options.onSuccess)(a, ...args)
-            if (t === null) {
-              return
-            }
-            yield* toast.success(
-              t,
-              toastId !== undefined ? { id: toastId, timeout: baseTimeout } : { timeout: baseTimeout }
-            )
-          })),
-          Effect.tapCause(Effect.fnUntraced(function*(cause) {
-            yield* Effect.logDebug(
-              "WithToast - caught error cause: " + Cause.squash(cause),
-              Cause.hasInterruptsOnly(cause),
-              cause
-            )
-
-            if (Cause.hasInterruptsOnly(cause)) {
-              if (toastId) yield* toast.dismiss(toastId)
-              return
-            }
-
-            const t = yield* wrapEffect(options.onFailure)(Cause.findErrorOption(cause), ...args)
-            const opts = { timeout: baseTimeout * 2 }
-
-            if (typeof t === "object") {
-              return t.level === "warn"
-                ? yield* toast.warning(t.message, toastId !== undefined ? { ...opts, id: toastId } : opts)
-                : yield* toast.error(t.message, toastId !== undefined ? { ...opts, id: toastId } : opts)
-            }
-            yield* toast.error(t, toastId !== undefined ? { ...opts, id: toastId } : opts)
-          }, Effect.uninterruptible)),
-          toastId !== undefined ? Effect.provideService(CurrentToastId, CurrentToastId.of({ toastId })) : (_) => _
-        )
-      })
-  })
-}) {
-  static readonly DefaultWithoutDependencies = Layer.effect(this, this.make)
-  static readonly Default = this.DefaultWithoutDependencies
-
-  static readonly handle = <A, E, Args extends Array<unknown>, R, WaiR = never, SucR = never, ErrR = never>(
-    options: ToastOptions<A, E, Args, WaiR, SucR, ErrR>
-  ): (self: Effect.Effect<A, E, R>, ...args: Args) => Effect.Effect<A, E, R | WaiR | SucR | ErrR | WithToast> =>
-  (self, ...args) => this.use((_) => _<A, E, Args, R, WaiR, SucR, ErrR>(options)(self, ...args))
-}
+export * from "effect-app/withToast"

package/test/Mutation.test.ts

@@ -1,9 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { it } from "@effect/vitest"
-import { Cause, Effect, Exit, Fiber, Option } from "effect-app"
+import * as Effect from "effect-app/Effect"
+import * as Option from "effect-app/Option"
+import * as Cause from "effect/Cause"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import { TestClock } from "effect/testing"
 import { CommandContext, DefaultIntl } from "../src/commander.js"
 import { AsyncResult } from "../src/lib.js"
-import { useExperimental } from "./stubs.js"
+import { useExperimental, useExperimentalE } from "./stubs.js"
 
 const unwrap = <A, E>(r: Fiber.Fiber<Exit.Exit<A, E>, never>) => Fiber.join(r).pipe(Effect.flatten)
 
@@ -317,8 +322,8 @@ it.live("with toasts", () =>
         function*() {
           expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
 
-          expect(toasts.length).toBe(1)
-          expect(toasts[0].message).toBe("Test Action executing...")
+          // fast actions complete before the 1s waiting-toast delay, so no waiting toast is shown
+          expect(toasts.length).toBe(0)
 
           return "test-value"
         },
@@ -358,7 +363,7 @@ it.live("interrupted", () =>
 
       const command = Command.fn("Test Action")(
         function*() {
-          expect(toasts.length).toBe(1)
+          expect(toasts.length).toBe(0)
           yield* Effect.interrupt
           return "test-value"
         },
@@ -385,7 +390,7 @@ it.live("fail", () =>
 
       const command = Command.fn("Test Action")(
         function*() {
-          expect(toasts.length).toBe(1)
+          expect(toasts.length).toBe(0)
           return yield* Effect.fail({ message: "Boom!" })
         },
         Command.withDefaultToast(),
@@ -400,9 +405,30 @@ it.live("fail", () =>
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
-      expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
+      expect(toasts[0].type).toBe("warning")
+      expect(toasts[0].message).toContain("Test Action Failed:\nBoom!")
+      expect(toasts[0].message).toMatch(/Trace: [a-f0-9]{32}/)
+      expect(toasts[0].message).toMatch(/Span: [a-f0-9]{16}/)
     }))
 
+it.live("fail with showSpanInfo disabled", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const Command = useExperimental({ toasts, messages: DefaultIntl.en })
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          return yield* Effect.fail({ message: "Boom!" })
+        },
+        Command.withDefaultToast({ showSpanInfo: false })
+      )
+
+      yield* Fiber.join(command.handle())
+
+      expect(toasts.length).toBe(1)
+      expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
+    }))
 it.live("fail and recover", () =>
   Effect
     .gen(function*() {
@@ -412,7 +438,7 @@ it.live("fail and recover", () =>
 
       const command = Command.fn("Test Action")(
         function*() {
-          expect(toasts.length).toBe(1)
+          expect(toasts.length).toBe(0)
           return yield* Effect.fail({ message: "Boom!" })
         },
         Effect.orElseSucceed(() => "recovered"), // we recover from the error here, so the final result is success
@@ -440,7 +466,7 @@ it.live("defect", () =>
 
       const command = Command.fn("Test Action")(
         function*() {
-          expect(toasts.length).toBe(1)
+          expect(toasts.length).toBe(0)
           return yield* Effect.die({ message: "Boom!" })
         },
         Command.withDefaultToast(),
@@ -456,7 +482,8 @@ it.live("defect", () =>
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
-      expect(toasts[0].message).toBe("Test Action unexpected error, please try again shortly.")
+      expect(toasts[0].type).toBe("error")
+      expect(toasts[0].message).toContain("Test Action unexpected error, please try again shortly.")
     }))
 
 it.live("works with alt", () =>
@@ -630,8 +657,8 @@ it.live("with toasts with alt", () =>
           function*() {
             expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
 
-            expect(toasts.length).toBe(1)
-            expect(toasts[0].message).toBe("Test Action executing...")
+            // fast actions complete before the 1s waiting-toast delay, so no waiting toast is shown
+            expect(toasts.length).toBe(0)
 
             return "test-value"
           },
@@ -668,7 +695,7 @@ it.live("interrupted with alt", () =>
       const command = Command.alt("Test Action")(
         Effect.fnUntraced(
           function*() {
-            expect(toasts.length).toBe(1)
+            expect(toasts.length).toBe(0)
             // @effect-diagnostics-next-line missingReturnYieldStar:off
             yield* Effect.interrupt
             return "test-value"
@@ -698,7 +725,7 @@ it.live("fail with alt", () =>
       const command = Command.alt("Test Action")(
         Effect.fnUntraced(
           function*() {
-            expect(toasts.length).toBe(1)
+            expect(toasts.length).toBe(0)
             return yield* Effect.fail({ message: "Boom!" })
           },
           Command.withDefaultToast(),
@@ -714,7 +741,8 @@ it.live("fail with alt", () =>
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
-      expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
+      expect(toasts[0].type).toBe("warning")
+      expect(toasts[0].message).toContain("Test Action Failed:\nBoom!")
     }))
 
 it.live("fail and recover with alt", () =>
@@ -727,7 +755,7 @@ it.live("fail and recover with alt", () =>
       const command = Command.alt("Test Action")(
         Effect.fnUntraced(
           function*() {
-            expect(toasts.length).toBe(1)
+            expect(toasts.length).toBe(0)
             return yield* Effect.fail({ message: "Boom!" })
           },
           Effect.orElseSucceed(() => "recovered"), // we recover from the error here, so the final result is success
@@ -747,6 +775,64 @@ it.live("fail and recover with alt", () =>
       expect(toasts[0].message).toBe("Test Action Success")
     }))
 
+it.effect("slow action shows waiting toast after the 1s delay", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const Command = yield* useExperimentalE({ toasts, messages: DefaultIntl.en })
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          // before 1s the waiting toast must NOT have surfaced yet
+          expect(toasts.length).toBe(0)
+          yield* Effect.sleep("1100 millis")
+          // after the delay window the waiting info toast should be visible
+          expect(toasts.length).toBe(1)
+          expect(toasts[0].type).toBe("info")
+          expect(toasts[0].message).toBe("Test Action executing...")
+          return "test-value"
+        },
+        Command.withDefaultToast()
+      )
+
+      const fiber = command.handle()
+      yield* TestClock.adjust("2 seconds")
+      const r = yield* unwrap(fiber)
+
+      expect(r).toBe("test-value")
+      // waiting toast is replaced (same id) with the success toast
+      expect(toasts.length).toBe(1)
+      expect(toasts[0].type).toBe("success")
+      expect(toasts[0].message).toBe("Test Action Success")
+    }))
+
+it.effect("slow failing action surfaces waiting toast then shows error", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const Command = yield* useExperimentalE({ toasts, messages: DefaultIntl.en })
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(toasts.length).toBe(0)
+          yield* Effect.sleep("1100 millis")
+          expect(toasts.length).toBe(1)
+          expect(toasts[0].type).toBe("info")
+          return yield* Effect.fail({ message: "Boom!" })
+        },
+        Command.withDefaultToast()
+      )
+
+      const fiber = command.handle()
+      yield* TestClock.adjust("2 seconds")
+      const r = yield* Fiber.join(fiber)
+
+      expect(Exit.isFailure(r) && Cause.hasFails(r.cause)).toBe(true)
+      expect(toasts.length).toBe(1)
+      expect(toasts[0].type).toBe("warning")
+      expect(toasts[0].message).toContain("Test Action Failed:\nBoom!")
+    }))
+
 it.live("defect with alt", () =>
   Effect
     .gen(function*() {
@@ -774,7 +860,8 @@ it.live("defect with alt", () =>
       expect(command.waiting).toBe(false)
       expect(Exit.isFailure(AsyncResult.toExit(command.result))).toBe(true)
       expect(toasts.length).toBe(1) // toast should show error
-      expect(toasts[0].message).toBe("Test Action unexpected error, please try again shortly.")
+      expect(toasts[0].type).toBe("error")
+      expect(toasts[0].message).toContain("Test Action unexpected error, please try again shortly.")
     }))
 
 describe("state-in-toast", () => {