@effect-app/vue 2.51.18 → 2.52.0

package/test/Mutation.test.ts

@@ -0,0 +1,296 @@
+import { it } from "@effect/vitest"
+import { Cause, Effect, Exit, Fiber, Option } from "effect-app"
+import { CommandContext, DefaultIntl } from "../src/experimental/useCommand.js"
+import { Result } from "../src/lib.js"
+import { useExperimental } from "./stubs.js"
+
+it.live("works", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+          expect(command.value.waiting).toBe(true)
+
+          expect(yield* CommandContext).toEqual({ action: "Test Action" })
+
+          expect(toasts.length).toBe(0)
+
+          return "test-value"
+        },
+        Effect.tap(Effect.fnUntraced(function*() {
+          expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+        })),
+        Effect.tap(() =>
+          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+        ),
+        Effect.tap(() => executed = true)
+      )
+      expect(command.value.action).toBe("Test Action")
+
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+      expect(command.value.waiting).toBe(false)
+
+      expect(r).toBe("test-value") // to confirm that the initial function has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+
+      expect(command.value.result.pipe(Result.value)).toEqual(Option.some("test-value"))
+
+      expect(toasts.length).toBe(0)
+    }))
+
+it.live("has custom action name", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: { "action.Test Action": "Test Action Translated" } })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+
+          expect(yield* CommandContext).toEqual({ action: "Test Action Translated" })
+          return "test-value"
+        },
+        Effect.tap(() => executed = true)
+      )
+      expect(command.value.action).toBe("Test Action Translated")
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toBe("test-value") // to confirm that the initial function has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+    }))
+
+it.live("can map the result", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+
+          return "test-value"
+        },
+        Effect.map((_) => _ + _),
+        Effect.tap(() => executed = true)
+      )
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toBe("test-valuetest-value") // to confirm that the initial function and map has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+    }))
+
+it.live("can receive and use input", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.fn("Test Action")(
+        function*(input1: number, input2: string) {
+          expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+
+          return { input1, input2 }
+        },
+        Effect.tap(() => executed = true)
+      )
+      const r = yield* Fiber.join(command.value(1, "2")).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toEqual({ input1: 1, input2: "2" }) // to confirm that the initial function has ran and received input.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+    }))
+
+it.live("can replace the result", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: { "action.Test Action": "Test Action Translated" } })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+
+          return "test-value"
+        },
+        Effect.zipRight(Effect.succeed(42)),
+        Effect.tap(() => executed = true)
+      )
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toBe(42) // to confirm that the initial function and zipRight has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+    }))
+
+it.live("with toasts", () =>
+  Effect
+    .gen(function*() {
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({
+        toasts,
+        messages: DefaultIntl.en
+      })
+      const Command = useCommand()
+
+      let executed = false
+
+      const command = Command.fn("Test Action")(
+        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...")
+
+          return "test-value"
+        },
+        Effect.tap(Effect.fnUntraced(function*() {
+          expect(yield* Effect.currentSpan.pipe(Effect.map((_) => _.name))).toBe("Test Action")
+        })),
+        Effect.tap(() =>
+          Effect.currentSpan.pipe(Effect.map((_) => _.name), Effect.tap((_) => expect(_).toBe("Test Action")))
+        ),
+        Command.withDefaultToast,
+        Effect.tap(() => executed = true)
+      )
+
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed, so we flatten it.
+
+      expect(r).toBe("test-value") // to confirm that the initial function has ran.
+      expect(executed).toBe(true) // to confirm that the combinators have ran.
+
+      expect(toasts.length).toBe(1)
+      expect(toasts[0].message).toBe("Test Action Success")
+    }))
+
+it.live("interrupted", () =>
+  Effect
+    .gen(function*() {
+      let executed = false
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: DefaultIntl.en })
+      const Command = useCommand()
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(toasts.length).toBe(1)
+          yield* Effect.interrupt
+          return "test-value"
+        },
+        Command.withDefaultToast,
+        Effect.tap(() => executed = true)
+      )
+
+      const r = yield* Fiber.join(command.value()) // we receive an Exit as errors/results are processed
+
+      expect(executed).toBe(false) // we were interrupted after all :)
+      expect(Exit.isInterrupted(r)).toBe(true) // to confirm that the initial function has interrupted
+
+      expect(command.value.waiting).toBe(false)
+      expect(Exit.isInterrupted(Result.toExit(command.value.result))).toBe(true)
+      expect(toasts.length).toBe(0) // toast is removed on interruption. TODO: maybe a nicer user experience can be had?
+    }))
+
+it.live("fail", () =>
+  Effect
+    .gen(function*() {
+      let executed = false
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: DefaultIntl.en })
+      const Command = useCommand()
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(toasts.length).toBe(1)
+          return yield* Effect.fail({ message: "Boom!" })
+        },
+        Command.withDefaultToast,
+        Effect.tap(() => executed = true)
+      )
+
+      const r = yield* Fiber.join(command.value()) // we receive an Exit as errors/results are processed
+
+      expect(executed).toBe(false) // we failed after all :)
+      expect(Exit.isFailure(r) && Cause.isFailure(r.cause)).toBe(true) // to confirm that the initial function has failed
+
+      expect(command.value.waiting).toBe(false)
+      expect(Exit.isFailure(Result.toExit(command.value.result))).toBe(true)
+      expect(toasts.length).toBe(1) // toast should show error
+      expect(toasts[0].message).toBe("Test Action Failed:\nBoom!")
+    }))
+
+it.live("fail and recover", () =>
+  Effect
+    .gen(function*() {
+      let executed = false
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: DefaultIntl.en })
+      const Command = useCommand()
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(toasts.length).toBe(1)
+          return yield* Effect.fail({ message: "Boom!" })
+        },
+        Effect.catchAll(() => Effect.succeed("recovered")), // we recover from the error here, so the final result is success
+        Command.withDefaultToast,
+        Effect.tap(() => executed = true)
+      )
+
+      const r = yield* Fiber.join(command.value()).pipe(Effect.flatten) // we receive an Exit as errors/results are processed
+
+      expect(executed).toBe(true) // we recovered after all :)
+      expect(r).toBe("recovered") // to confirm that the initial function has failed but we recovered
+
+      expect(command.value.waiting).toBe(false)
+      expect(Result.toExit(command.value.result)).toEqual(Exit.succeed("recovered"))
+      expect(toasts.length).toBe(1) // toast should show error
+      expect(toasts[0].message).toBe("Test Action Success")
+    }))
+
+it.live("defect", () =>
+  Effect
+    .gen(function*() {
+      let executed = false
+      const toasts: any[] = []
+      const { useCommand } = useExperimental({ toasts, messages: DefaultIntl.en })
+      const Command = useCommand()
+
+      const command = Command.fn("Test Action")(
+        function*() {
+          expect(toasts.length).toBe(1)
+          return yield* Effect.die({ message: "Boom!" })
+        },
+        Command.withDefaultToast,
+        Effect.tap(() => executed = true)
+      )
+
+      const r = yield* Fiber.join(command.value()) // we receive an Exit as errors/results are processed
+      // TODO: confirm we reported error
+
+      expect(executed).toBe(false) // we died after all :)
+      expect(Exit.isFailure(r) && Cause.isDie(r.cause)).toBe(true) // to confirm that the initial function has died
+
+      expect(command.value.waiting).toBe(false)
+      expect(Exit.isFailure(Result.toExit(command.value.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.")
+    }))

package/test/dist/Mutation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mutation.test.d.ts","sourceRoot":"","sources":["../Mutation.test.ts"],"names":[],"mappings":""}

package/test/dist/stubs.d.ts

@@ -0,0 +1,68 @@
+import { type MessageFormatElement } from "@formatjs/icu-messageformat-parser";
+export declare const useExperimental: (options?: {
+    messages?: Record<string, string> | Record<string, MessageFormatElement[]>;
+    toasts: any[];
+}) => {
+    useConfirm: () => {
+        confirm: (message?: string) => import("effect/Effect").Effect<boolean, never, never>;
+        confirmOrInterrupt: (message?: string) => import("effect/Effect").Effect<void, never, never>;
+    };
+    useCommand: () => {
+        confirmOrInterrupt: (message?: string | undefined) => import("effect/Effect").Effect<void, never, import("../src/experimental/useCommand.js").CommandContext>;
+        withDefaultToast: <A, E>(self: import("effect/Effect").Effect<A, E, import("../src/experimental/useCommand.js").CommandContext>, errorRenderer?: ((e: E) => string | undefined) | undefined) => import("effect/Effect").Effect<A, E, import("../src/experimental/useCommand.js").CommandContext>;
+        fn: (actionName: string) => {
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>, AEff, Args extends Array<any>>(body: (...args: Args) => Generator<Eff, AEff, never>): import("vue").ComputedRef<((...a: Args) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<AEff, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_1, infer _R>>] ? E_1 : never>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<AEff, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_1, infer _R>>] ? E_1 : never>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_1, Args_1 extends Array<any>, A extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_1) => Generator<Eff, AEff_1, never>, a: (_: import("effect/Effect").Effect<AEff_1, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_1, infer _R>>] ? E_1 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A): import("vue").ComputedRef<((...a: Args_1) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<A>, import("effect/Effect").Effect.Error<A>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<A>, import("effect/Effect").Effect.Error<A>>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_2, Args_2 extends Array<any>, A_1, B extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_2) => Generator<Eff, AEff_2, never>, a: (_: import("effect/Effect").Effect<AEff_2, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_1, infer _R>>] ? E_1 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A_1, b: (_: A_1) => B): import("vue").ComputedRef<((...a: Args_2) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<B>, import("effect/Effect").Effect.Error<B>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<B>, import("effect/Effect").Effect.Error<B>>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_3, Args_3 extends Array<any>, A_2, B_1, C extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_3) => Generator<Eff, AEff_3, never>, a: (_: import("effect/Effect").Effect<AEff_3, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_1, infer _R>>] ? E_1 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A_2, b: (_: A_2) => B_1, c: (_: B_1) => C): import("vue").ComputedRef<((...a: Args_3) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<C>, import("effect/Effect").Effect.Error<C>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<C>, import("effect/Effect").Effect.Error<C>>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_4, Args_4 extends Array<any>, A_3, B_2, C_1, D extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_4) => Generator<Eff, AEff_4, never>, a: (_: import("effect/Effect").Effect<AEff_4, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_1, infer _R>>] ? E_1 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A_3, b: (_: A_3) => B_2, c: (_: B_2) => C_1, d: (_: C_1) => D): import("vue").ComputedRef<((...a: Args_4) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<D>, import("effect/Effect").Effect.Error<D>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<D>, import("effect/Effect").Effect.Error<D>>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_5, Args_5 extends Array<any>, A_4, B_3, C_2, D_1, E_1 extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_5) => Generator<Eff, AEff_5, never>, a: (_: import("effect/Effect").Effect<AEff_5, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_2, infer _R>>] ? E_2 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A_4, b: (_: A_4) => B_3, c: (_: B_3) => C_2, d: (_: C_2) => D_1, e: (_: D_1) => E_1): import("vue").ComputedRef<((...a: Args_5) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<E_1>, import("effect/Effect").Effect.Error<E_1>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<E_1>, import("effect/Effect").Effect.Error<E_1>>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_6, Args_6 extends Array<any>, A_5, B_4, C_3, D_2, E_2, F extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_6) => Generator<Eff, AEff_6, never>, a: (_: import("effect/Effect").Effect<AEff_6, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_3, infer _R>>] ? E_3 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A_5, b: (_: A_5) => B_4, c: (_: B_4) => C_3, d: (_: C_3) => D_2, e: (_: D_2) => E_2, f: (_: E_2) => F): import("vue").ComputedRef<((...a: Args_6) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<F>, import("effect/Effect").Effect.Error<F>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<F>, import("effect/Effect").Effect.Error<F>>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_7, Args_7 extends Array<any>, A_6, B_5, C_4, D_3, E_3, F_1, G extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_7) => Generator<Eff, AEff_7, never>, a: (_: import("effect/Effect").Effect<AEff_7, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_4, infer _R>>] ? E_4 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A_6, b: (_: A_6) => B_5, c: (_: B_5) => C_4, d: (_: C_4) => D_3, e: (_: D_3) => E_3, f: (_: E_3) => F_1, g: (_: F_1) => G): import("vue").ComputedRef<((...a: Args_7) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<G>, import("effect/Effect").Effect.Error<G>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<G>, import("effect/Effect").Effect.Error<G>>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_8, Args_8 extends Array<any>, A_7, B_6, C_5, D_4, E_4, F_2, G_1, H extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_8) => Generator<Eff, AEff_8, never>, a: (_: import("effect/Effect").Effect<AEff_8, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_5, infer _R>>] ? E_5 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A_7, b: (_: A_7) => B_6, c: (_: B_6) => C_5, d: (_: C_5) => D_4, e: (_: D_4) => E_4, f: (_: E_4) => F_2, g: (_: F_2) => G_1, h: (_: G_1) => H): import("vue").ComputedRef<((...a: Args_8) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<H>, import("effect/Effect").Effect.Error<H>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<H>, import("effect/Effect").Effect.Error<H>>;
+                waiting: boolean;
+            }>;
+            <Eff extends import("effect/Utils").YieldWrap<import("effect/Effect").Effect<any, any, any>>, AEff_9, Args_9 extends Array<any>, A_8, B_7, C_6, D_5, E_5, F_3, G_2, H_1, I extends import("effect/Effect").Effect<any, any, import("../src/experimental/useCommand.js").CommandContext>>(body: (...args: Args_9) => Generator<Eff, AEff_9, never>, a: (_: import("effect/Effect").Effect<AEff_9, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A, infer E_6, infer _R>>] ? E_6 : never, [Eff] extends [never] ? never : [Eff] extends [import("effect/Utils").YieldWrap<import("effect/Effect").Effect<infer _A_1, infer _E, infer R_1>>] ? R_1 : never>) => A_8, b: (_: A_8) => B_7, c: (_: B_7) => C_6, d: (_: C_6) => D_5, e: (_: D_5) => E_5, f: (_: E_5) => F_3, g: (_: F_3) => G_2, h: (_: G_2) => H_1, i: (_: H_1) => I): import("vue").ComputedRef<((...a: Args_9) => import("effect/Fiber").RuntimeFiber<import("effect/Exit").Exit<import("effect/Effect").Effect.Success<I>, import("effect/Effect").Effect.Error<I>>, never>) & {
+                action: string;
+                result: import("@effect-atom/atom/Result").Result<import("effect/Effect").Effect.Success<I>, import("effect/Effect").Effect.Error<I>>;
+                waiting: boolean;
+            }>;
+        };
+    };
+    useWithToast: () => <A_9, E_6, Args_10 extends ReadonlyArray<unknown>, R_1>(options: import("../src/experimental/useWithToast.js").ToastOptions<A_9, E_6, Args_10>) => (self: import("effect/Effect").Effect<A_9, E_6, R_1>, ...args: Args_10) => import("effect/Effect").Effect<A_9, E_6, R_1>;
+};
+//# sourceMappingURL=stubs.d.ts.map

package/test/dist/stubs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stubs.d.ts","sourceRoot":"","sources":["../stubs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,oCAAoC,CAAA;AA0B9E,eAAO,MAAM,eAAe,GAC1B,UAAU;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,EAAE,CAAA;CAAE;;yBAnBlG,CAAC;oCAEuC,CAAC;;;oCAGd,CAAC;sJAM7B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iOAwDixU,GAAI;CAD3xU,CAAA"}

package/test/dist/stubs.js

@@ -0,0 +1,60 @@
+import * as Intl from "@formatjs/intl";
+import { Runtime } from "effect-app";
+import { computed, ref } from "vue";
+import { makeExperimental } from "../src/experimental/makeExperimental.js";
+// const mockIntl = {
+//   locale: ref("en" as const),
+//   trans: (id: string) => id,
+//   intl: ref({ formatMessage: (msg: { id: string }) => msg.id })
+// } as unknown as ReturnType<ReturnType<typeof makeIntl<string>>["useIntl"]>
+const makeUseIntl = (messages) => () => {
+    const locale = ref("en");
+    const intlCache = Intl.createIntlCache();
+    const intl = Intl.createIntl({
+        locale: locale.value,
+        messages
+    }, intlCache);
+    return { locale, intl: computed(() => intl), trans: (id, values) => intl.formatMessage({ id }, values) };
+};
+export const useExperimental = (options) => {
+    const toasts = options?.toasts ?? [];
+    const useIntl = makeUseIntl({ ...options?.messages });
+    const dismiss = (id) => {
+        const idx = toasts.findIndex((_) => _.id === id);
+        if (idx > -1) {
+            const toast = toasts[idx];
+            clearTimeout(toast.timeoutId);
+            toasts.splice(idx, 1);
+        }
+    };
+    const fakeToast = (message, options) => {
+        const id = options?.id ?? Math.random().toString(36).substring(2, 15);
+        console.log(`Toast [${id}]: ${message}`, options);
+        options = { ...options, id };
+        const idx = toasts.findIndex((_) => _.id === id);
+        if (idx > -1) {
+            const toast = toasts[idx];
+            clearTimeout(toast.timeoutId);
+            Object.assign(toast, { message, options });
+            toast.timeoutId = setTimeout(() => {
+                toasts.splice(idx, 1);
+            }, options?.timeout ?? 3000);
+        }
+        else {
+            const toast = { id, message, options };
+            toast.timeoutId = setTimeout(() => {
+                toasts.splice(idx, 1);
+            }, options?.timeout ?? 3000);
+            toasts.push(toast);
+        }
+        return id;
+    };
+    return makeExperimental(useIntl, () => ({
+        error: fakeToast,
+        warning: fakeToast,
+        success: fakeToast,
+        info: fakeToast,
+        dismiss
+    }), Runtime.defaultRuntime);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R1YnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zdHVicy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssSUFBSSxNQUFNLGdCQUFnQixDQUFBO0FBQ3RDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFDcEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxHQUFHLEVBQUUsTUFBTSxLQUFLLENBQUE7QUFDbkMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUNBQXlDLENBQUE7QUFHMUUscUJBQXFCO0FBQ3JCLGdDQUFnQztBQUNoQywrQkFBK0I7QUFDL0Isa0VBQWtFO0FBQ2xFLDZFQUE2RTtBQUU3RSxNQUFNLFdBQVcsR0FBRyxDQUFDLFFBQXlFLEVBQUUsRUFBRSxDQUFDLEdBQUcsRUFBRTtJQUN0RyxNQUFNLE1BQU0sR0FBRyxHQUFHLENBQUMsSUFBYSxDQUFDLENBQUE7SUFDakMsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFBO0lBQ3hDLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQzFCO1FBQ0UsTUFBTSxFQUFFLE1BQU0sQ0FBQyxLQUFLO1FBQ3BCLFFBQVE7S0FDVCxFQUNELFNBQVMsQ0FDVixDQUFBO0lBQ0QsT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsUUFBUSxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQU8sRUFBRSxNQUFXLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsRUFBRSxFQUFFLEVBQUUsRUFBRSxNQUFNLENBQUMsRUFBRSxDQUFBO0FBQ3BILENBQUMsQ0FBQTtBQUVELE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxDQUM3QixPQUF1RyxFQUN2RyxFQUFFO0lBQ0YsTUFBTSxNQUFNLEdBQVUsT0FBTyxFQUFFLE1BQU0sSUFBSSxFQUFFLENBQUE7SUFDM0MsTUFBTSxPQUFPLEdBQUcsV0FBVyxDQUFDLEVBQUUsR0FBRyxPQUFPLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQTtJQUVyRCxNQUFNLE9BQU8sR0FBRyxDQUFDLEVBQVcsRUFBRSxFQUFFO1FBQzlCLE1BQU0sR0FBRyxHQUFHLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUE7UUFDaEQsSUFBSSxHQUFHLEdBQUcsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUNiLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQTtZQUN6QixZQUFZLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFBO1lBQzdCLE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFBO1FBQ3ZCLENBQUM7SUFDSCxDQUFDLENBQUE7SUFDRCxNQUFNLFNBQVMsR0FBRyxDQUFDLE9BQWUsRUFBRSxPQUE0QyxFQUFFLEVBQUU7UUFDbEYsTUFBTSxFQUFFLEdBQUcsT0FBTyxFQUFFLEVBQUUsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUE7UUFDckUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLEVBQUUsTUFBTSxPQUFPLEVBQUUsRUFBRSxPQUFPLENBQUMsQ0FBQTtRQUVqRCxPQUFPLEdBQUcsRUFBRSxHQUFHLE9BQU8sRUFBRSxFQUFFLEVBQUUsQ0FBQTtRQUM1QixNQUFNLEdBQUcsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFBO1FBQ2hELElBQUksR0FBRyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDYixNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDekIsWUFBWSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQTtZQUM3QixNQUFNLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFBO1lBQzFDLEtBQUssQ0FBQyxTQUFTLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtnQkFDaEMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUE7WUFDdkIsQ0FBQyxFQUFFLE9BQU8sRUFBRSxPQUFPLElBQUksSUFBSSxDQUFDLENBQUE7UUFDOUIsQ0FBQzthQUFNLENBQUM7WUFDTixNQUFNLEtBQUssR0FBUSxFQUFFLEVBQUUsRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUE7WUFDM0MsS0FBSyxDQUFDLFNBQVMsR0FBRyxVQUFVLENBQUMsR0FBRyxFQUFFO2dCQUNoQyxNQUFNLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQTtZQUN2QixDQUFDLEVBQUUsT0FBTyxFQUFFLE9BQU8sSUFBSSxJQUFJLENBQUMsQ0FBQTtZQUM1QixNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFBO1FBQ3BCLENBQUM7UUFDRCxPQUFPLEVBQUUsQ0FBQTtJQUNYLENBQUMsQ0FBQTtJQUVELE9BQU8sZ0JBQWdCLENBQ3JCLE9BQU8sRUFDUCxHQUFHLEVBQUUsQ0FBQyxDQUFDO1FBQ0wsS0FBSyxFQUFFLFNBQVM7UUFDaEIsT0FBTyxFQUFFLFNBQVM7UUFDbEIsT0FBTyxFQUFFLFNBQVM7UUFDbEIsSUFBSSxFQUFFLFNBQVM7UUFDZixPQUFPO0tBQ1IsQ0FBQyxFQUNGLE9BQU8sQ0FBQyxjQUFjLENBQ3ZCLENBQUE7QUFDSCxDQUFDLENBQUEifQ==

package/test/stubs.ts

@@ -0,0 +1,75 @@
+import { type MessageFormatElement } from "@formatjs/icu-messageformat-parser"
+import * as Intl from "@formatjs/intl"
+import { Runtime } from "effect-app"
+import { computed, ref } from "vue"
+import { makeExperimental } from "../src/experimental/makeExperimental.js"
+import { type ToastId } from "../src/experimental/useWithToast.js"
+
+// const mockIntl = {
+//   locale: ref("en" as const),
+//   trans: (id: string) => id,
+//   intl: ref({ formatMessage: (msg: { id: string }) => msg.id })
+// } as unknown as ReturnType<ReturnType<typeof makeIntl<string>>["useIntl"]>
+
+const makeUseIntl = (messages: Record<string, string> | Record<string, MessageFormatElement[]>) => () => {
+  const locale = ref("en" as const)
+  const intlCache = Intl.createIntlCache()
+  const intl = Intl.createIntl<typeof locale.value>(
+    {
+      locale: locale.value,
+      messages
+    },
+    intlCache
+  )
+  return { locale, intl: computed(() => intl), trans: (id: any, values: any) => intl.formatMessage({ id }, values) }
+}
+
+export const useExperimental = (
+  options?: { messages?: Record<string, string> | Record<string, MessageFormatElement[]>; toasts: any[] }
+) => {
+  const toasts: any[] = options?.toasts ?? []
+  const useIntl = makeUseIntl({ ...options?.messages })
+
+  const dismiss = (id: ToastId) => {
+    const idx = toasts.findIndex((_) => _.id === id)
+    if (idx > -1) {
+      const toast = toasts[idx]
+      clearTimeout(toast.timeoutId)
+      toasts.splice(idx, 1)
+    }
+  }
+  const fakeToast = (message: string, options?: { timeout?: number; id?: ToastId }) => {
+    const id = options?.id ?? Math.random().toString(36).substring(2, 15)
+    console.log(`Toast [${id}]: ${message}`, options)
+
+    options = { ...options, id }
+    const idx = toasts.findIndex((_) => _.id === id)
+    if (idx > -1) {
+      const toast = toasts[idx]
+      clearTimeout(toast.timeoutId)
+      Object.assign(toast, { message, options })
+      toast.timeoutId = setTimeout(() => {
+        toasts.splice(idx, 1)
+      }, options?.timeout ?? 3000)
+    } else {
+      const toast: any = { id, message, options }
+      toast.timeoutId = setTimeout(() => {
+        toasts.splice(idx, 1)
+      }, options?.timeout ?? 3000)
+      toasts.push(toast)
+    }
+    return id
+  }
+
+  return makeExperimental(
+    useIntl,
+    () => ({
+      error: fakeToast,
+      warning: fakeToast,
+      success: fakeToast,
+      info: fakeToast,
+      dismiss
+    }),
+    Runtime.defaultRuntime
+  )
+}

package/tsconfig.src.json

@@ -2,7 +2,8 @@
     "extends": "../../tsconfig.base.json",
     "compilerOptions": {
         "lib": [
-            "esnext"
+            "esnext",
+            "DOM"
         ],
         "tsBuildInfoFile": "./dist/.tsbuildinfo",
         "esModuleInterop": true,

package/vitest.config.ts

@@ -1,5 +1,18 @@
 /// <reference types="vitest" />
-import { defineConfig } from "vite"
+import { defineConfig } from "vitest/config"
+import vue from '@vitejs/plugin-vue'
 import makeConfig from "../../vite.config.base"
 
-export default defineConfig(makeConfig(__dirname))
+export default defineConfig({
+  ...makeConfig(__dirname),
+  plugins: [vue()],
+  test: {
+    environment: 'jsdom',
+    include: ['src/**/*.test.{ts,tsx}', '**/test/**/*.test.{ts,tsx}', '**/__tests__/**/*.test.{ts,tsx}'],
+    exclude: ['node_modules/**', 'dist/**'],
+    globals: true
+  },
+  optimizeDeps: {
+    exclude: ['**/__tests__/**', '**/test/**', '**/*.test.*']
+  }
+})