@effect-app/vue 4.0.0-beta.184 → 4.0.0-beta.186

package/src/commander.ts

@@ -34,7 +34,7 @@ export type StreamMutationCallOptions<A, E> = {
 }
 
 /**
- * The result of invoking a `mutateStream` factory: the `execute` function (or
+ * The result of invoking a `mutateToResult` factory: the `execute` function (or
  * `Effect`, when the request takes no input) carries `id`, plus `running` and
  * `progress` when the factory was called with a `progress` formatter. Pass
  * directly to `Command.fn` / `Command.wrap` / `Command.wrapStream`, or invoke
@@ -218,7 +218,7 @@ export declare namespace Commander {
     /** reactive */
     result: AsyncResult.AsyncResult<A, E>
     /**
-     * reactive – set when the command wraps a stream (`wrapStream` / `wrap` with `mutateStream`)
+     * reactive – set when the command wraps a stream (`wrapStream` / `wrap` with `mutateToResult`)
      * or when the `progress` option is provided to `fn`.
      * Reflects the live AsyncResult of the underlying stream.
      */
@@ -2204,6 +2204,7 @@ export const CommanderStatic = {
    *
    * Unlike `withDefaultToast` (which only wraps the initial `Effect`), this combinator:
    * - Shows the "waiting" toast **before** the stream starts
+   * - Updates the waiting toast with progress text when `progress` is set and a new element arrives
    * - Shows the "success" toast only **after** the stream drains fully without error
    * - Shows the "failure" toast if the stream errors or fails
    *
@@ -2214,7 +2215,12 @@ export const CommanderStatic = {
    * ```ts
    * Command.streamFn("exportData")(
    *   function*(arg, ctx) { return makeExportStream(arg.id) },
-   *   Command.withDefaultToastStream()
+   *   Command.withDefaultToastStream({
+   *     progress: (r) =>
+   *       AsyncResult.isSuccess(r) && r.value._tag === "OperationProgress"
+   *         ? { text: `${r.value.completed}/${r.value.total}`, percentage: r.value.completed / r.value.total * 100 }
+   *         : undefined
+   *   })
    * )
    * ```
    */
@@ -2237,6 +2243,8 @@ export const CommanderStatic = {
         | undefined
         | string
         | ((a: A, action: string, arg: NoInfer<Args>[0], ctx: NoInfer<Args>[1]) => string | null | undefined)
+      /** Map each stream element to a progress label. When non-`undefined`, updates both the active waiting toast and the `CommandProgress` service (for CommandButton progress display). */
+      progress?: (result: AsyncResult.AsyncResult<A, E>) => Progress | undefined
     }
   ) =>
   (
@@ -2300,8 +2308,20 @@ export const CommanderStatic = {
 
       const composed = rawStream.pipe(
         Stream.tap((v) =>
-          Effect.sync(() => {
+          Effect.gen(function*() {
             lastValue = v
+            if (options?.progress !== undefined) {
+              const p = options.progress(AsyncResult.success(v, { waiting: true }))
+              if (p !== undefined) {
+                // Update CommandProgress so CommandButton progress indicator is also driven
+                yield* CommandProgress.use((s) => s.update(p))
+                if (toastId !== undefined) {
+                  const progressText = typeof p === "string" ? p : p.text
+                  const msg = waitingMsg ? `${waitingMsg}\n${progressText}` : progressText
+                  yield* toast.info(msg, { id: toastId })
+                }
+              }
+            }
           })
         ),
         Stream.tapCause(Effect.fnUntraced(function*(cause) {
@@ -3265,14 +3285,14 @@ export class CommanderImpl<RT, RTHooks> {
       | StreamMutationFactory<Id, Arg, A, E, R>
       | {
         id: Id
-        mutateStream:
+        mutateToResult:
           | StreamMutationFactory<Id, Arg, A, E, R>
           | StreamMutationCallable<Id, Arg, A, E, R>
       }
       | StreamMutationCallable<Id, Arg, A, E, R>,
     options?: FnOptions<Id, I18nKey, State>
   ): Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R> => {
-    if (mutation !== null && typeof mutation === "object" && "mutateStream" in mutation) {
+    if (mutation !== null && typeof mutation === "object" && "mutateToResult" in mutation) {
       return this.wrapStream(mutation as any, options) as any
     }
     if (isStreamCallable(mutation) || isStreamFactory(mutation)) {
@@ -3315,18 +3335,18 @@ export class CommanderImpl<RT, RTHooks> {
   }
 
   /**
-   * Define a Command from a stream-type mutation (`mutateStream` factory).
+   * Define a Command from a stream-type mutation (`mutateToResult` factory).
    * The stream's reactive `AsyncResult` ref is exposed as `running` for independent progress tracking.
    * The command's own `result` reflects the execution outcome of the `execute` function.
    * Supports the same combinator pipeline as `wrap` (e.g. `withDefaultToast`).
    *
    * Each invocation of the resulting wrap call produces a fresh `[ref, execute]` pair
-   * (the `mutateStream` factory is called once per build), so independent commands
+   * (the `mutateToResult` factory is called once per build), so independent commands
    * don't share progress state.
    *
    * Accepts either:
-   * - An object with `id` and `mutateStream` factory (e.g. a client entry)
-   * - The `mutateStream` factory directly (callable, with `id`)
+   * - An object with `id` and `mutateToResult` factory (e.g. a client entry)
+   * - The `mutateToResult` factory directly (callable, with `id`)
    * - An already-called factory result (`[resultRef, execute] & { id }`) — shared ref across builds
    *
    * @example
@@ -3335,10 +3355,10 @@ export class CommanderImpl<RT, RTHooks> {
    * const exportCmd = Command.wrapStream(client.myExport)()
    *
    * // Via factory directly:
-   * const exportCmd = Command.wrapStream(client.myExport.mutateStream)()
+   * const exportCmd = Command.wrapStream(client.myExport.mutateToResult)()
    *
    * // Via already-called factory (shared ref):
-   * const stream = client.myExport.mutateStream()
+   * const stream = client.myExport.mutateToResult()
    * const exportCmd = Command.wrapStream(stream)()
    * ```
    */
@@ -3354,7 +3374,7 @@ export class CommanderImpl<RT, RTHooks> {
     mutation:
       | {
         id: Id
-        mutateStream:
+        mutateToResult:
           | StreamMutationFactory<Id, Arg, A, E, R>
           | StreamMutationCallable<Id, Arg, A, E, R>
       }
@@ -3365,8 +3385,8 @@ export class CommanderImpl<RT, RTHooks> {
     const id = mutation.id
     // Resolve `source` to the factory or already-invoked callable.
     const source: StreamMutationFactory<Id, Arg, A, E, R> | StreamMutationCallable<Id, Arg, A, E, R> =
-      mutation !== null && typeof mutation === "object" && "mutateStream" in mutation
-        ? (mutation.mutateStream as any)
+      mutation !== null && typeof mutation === "object" && "mutateToResult" in mutation
+        ? (mutation.mutateToResult as any)
         : (mutation as any)
     const resolveCallable = (): StreamMutationCallable<Id, Arg, A, E, R> =>
       (isStreamFactory(source)

package/src/makeClient.ts

@@ -228,7 +228,7 @@ export type MutationWithExtensions<RT, Req> = Req extends
   : never
 
 /**
- * Options for invoking a `mutateStream` factory. Supplying `progress` produces
+ * Options for invoking a `mutateToResult` factory. Supplying `progress` produces
  * a tuple-with-id that carries `running` (the live AsyncResult ref) and
  * `progress` (a `ComputedRef<Progress | undefined>` formatted from each value),
  * which `Command.fn` / `Command.wrapStream` surface as the command's `running`
@@ -239,7 +239,7 @@ export type MutateStreamCallOptions<A, E> = {
 }
 
 /**
- * The `mutateStream` factory for a stream-type request handler. Always invoke
+ * The `mutateToResult` factory for a stream-type request handler. Always invoke
  * (optionally with `{ progress }`) to get a fresh callable `execute` — each call
  * produces a new state + execute pair so independent invocations don't share
  * state. The callable updates its underlying ref live with each emitted value
@@ -306,7 +306,7 @@ export type StreamFnStreamExtension<RT, Req> = Req extends
   : never
 
 /**
- * `mutateStream2` factory — like `mutateStream` but wraps per-invocation invalidation scaffolding
+ * `mutate` factory — like `mutateToResult` but wraps per-invocation invalidation scaffolding
  * into the stream itself (via `Stream.unwrap`) for use with `streamFn` combinators.
  */
 export type StreamMutation2WithExtensions<RT, Req> = Req extends
@@ -1043,11 +1043,11 @@ export const makeClient = <RT_, RTHooks>(
                 ...client[key],
                 request: h_,
                 streamQuery: useStreamQuery(client[key] as any),
-                mutateStream: streamMutFactory,
+                mutateToResult: streamMutFactory,
                 wrapStream: Command.wrapStream(streamMutFactory),
                 fn: Command.fn(client[key].id),
                 streamFn: useCommand().streamFn(client[key].id as any) as any,
-                mutateStream2: (() => {
+                mutate: (() => {
                   const sm2Act = useStreamMutation2()(client[key] as any, mergedInvalidation)
                   const originalHandler = (client[key] as any).handler
                   const sm2Handler = Stream.isStream(originalHandler)
@@ -1125,11 +1125,11 @@ export const makeClient = <RT_, RTHooks>(
             : { mutate: MutationWithExtensions<RT | RTHooks, CommandHandler<typeof client[Key]>> })
           & (StreamHandler<typeof client[Key]> extends never ? {}
             : {
-              mutateStream: StreamMutationWithExtensions<StreamHandler<typeof client[Key]>>
+              mutateToResult: StreamMutationWithExtensions<StreamHandler<typeof client[Key]>>
               wrapStream: StreamCommandWithExtensions<RT | RTHooks, StreamHandler<typeof client[Key]>>
               fn: StreamFnExtension<RT | RTHooks, StreamHandler<typeof client[Key]>>
               streamFn: StreamFnStreamExtension<RT | RTHooks, StreamHandler<typeof client[Key]>>
-              mutateStream2: StreamMutation2WithExtensions<RT | RTHooks, StreamHandler<typeof client[Key]>>
+              mutate: StreamMutation2WithExtensions<RT | RTHooks, StreamHandler<typeof client[Key]>>
             })
           & { Input: typeof client[Key] extends RequestHandlerWithInput<infer I, any, any, any, any, any> ? I : never }
       }

package/src/mutate.ts

@@ -418,7 +418,7 @@ export const useMakeMutation = () => {
  * `[ref, execute]` tuple. The outer Effect sets up per-invocation invalidation scaffolding
  * and returns a stream that triggers query invalidation via `Stream.ensuring` when it completes.
  *
- * Use this with `streamFn` / `Command.streamFn(id)(mutateStream2Handler, ...combinators)` so that
+ * Use this with `streamFn` / `Command.streamFn(id)(mutateHandler, ...combinators)` so that
  * the command manages its own reactive state internally. Unlike `makeStreamMutation`, no external
  * reactive result ref is created.
  *

package/test/dist/stubs.d.ts

@@ -2968,7 +2968,7 @@ export declare const useClient: (options?: {
         readonly type: "command" | "query" | "stream";
         readonly "~decodingServices"?: unknown;
     }, infer Id_3 extends string, infer Final_1> ? Request_3["type"] extends "stream" ? import("effect-app/client").RequestStreamHandler<A_3, E_3, R_4, Request_3, Id_3, Final_1> : never : never : never : never) extends never ? {} : {
-        mutateStream: import("../src/makeClient.js").StreamMutationWithExtensions<import("effect-app/client").RequestHandlers<never, never, M, import("effect-app/client").ExtractModuleName<M>>[Key] extends infer T_2 ? T_2 extends import("effect-app/client").RequestHandlers<never, never, M, import("effect-app/client").ExtractModuleName<M>>[Key] ? T_2 extends import("effect-app/client").RequestStreamHandlerWithInput<infer I_2, infer A_2, infer E_2, infer R_3, infer Request_2 extends S.Top & {
+        mutateToResult: import("../src/makeClient.js").StreamMutationWithExtensions<import("effect-app/client").RequestHandlers<never, never, M, import("effect-app/client").ExtractModuleName<M>>[Key] extends infer T_2 ? T_2 extends import("effect-app/client").RequestHandlers<never, never, M, import("effect-app/client").ExtractModuleName<M>>[Key] ? T_2 extends import("effect-app/client").RequestStreamHandlerWithInput<infer I_2, infer A_2, infer E_2, infer R_3, infer Request_2 extends S.Top & {
             readonly make: (...args: any[]) => any;
             _tag: string;
             fields: S.Struct.Fields;
@@ -3068,7 +3068,7 @@ export declare const useClient: (options?: {
             readonly type: "command" | "query" | "stream";
             readonly "~decodingServices"?: unknown;
         }, infer Id_3 extends string, infer Final_1> ? Request_3["type"] extends "stream" ? import("effect-app/client").RequestStreamHandler<A_3, E_3, R_4, Request_3, Id_3, Final_1> : never : never : never : never>;
-        mutateStream2: import("../src/makeClient.js").StreamMutation2WithExtensions<WithToast | (ApiClientFactory | Commander | (I18n | Toast.Toast)), import("effect-app/client").RequestHandlers<never, never, M, import("effect-app/client").ExtractModuleName<M>>[Key] extends infer T_2 ? T_2 extends import("effect-app/client").RequestHandlers<never, never, M, import("effect-app/client").ExtractModuleName<M>>[Key] ? T_2 extends import("effect-app/client").RequestStreamHandlerWithInput<infer I_2, infer A_2, infer E_2, infer R_3, infer Request_2 extends S.Top & {
+        mutate: import("../src/makeClient.js").StreamMutation2WithExtensions<WithToast | (ApiClientFactory | Commander | (I18n | Toast.Toast)), import("effect-app/client").RequestHandlers<never, never, M, import("effect-app/client").ExtractModuleName<M>>[Key] extends infer T_2 ? T_2 extends import("effect-app/client").RequestHandlers<never, never, M, import("effect-app/client").ExtractModuleName<M>>[Key] ? T_2 extends import("effect-app/client").RequestStreamHandlerWithInput<infer I_2, infer A_2, infer E_2, infer R_3, infer Request_2 extends S.Top & {
             readonly make: (...args: any[]) => any;
             _tag: string;
             fields: S.Struct.Fields;

package/test/makeClient.test.ts

@@ -278,8 +278,8 @@ it.skip("stream final type tests", () => {
   const { clientFor } = useClient()
   const client = clientFor(Something, undefined, somethingInvalidationResources)
 
-  const execNoFinal = client.StreamWithoutFinal.mutateStream()
-  const execWithFinal = client.StreamWithFinal.mutateStream()
+  const execNoFinal = client.StreamWithoutFinal.mutateToResult()
+  const execWithFinal = client.StreamWithFinal.mutateToResult()
 
   // Without `final`: execute input is {id: string} and resolves with void
   const _execNoFinalResult: ReturnType<typeof execNoFinal> = execNoFinal({ id: "test" })

package/test/streamFinal.test.ts

@@ -3,7 +3,7 @@
  *
  * The `final` option on a stream request schema lets callers model which type
  * the last emitted stream element is.  When present, the execute effect returned
- * by `mutateStream` resolves with that final value instead of `void`.
+ * by `mutateToResult` resolves with that final value instead of `void`.
  */
 import { expect, it } from "@effect/vitest"
 import { Effect, S } from "effect-app"
@@ -40,14 +40,14 @@ it.live("asStreamResult returns void and updates ref with each element", () =>
   }))
 
 // ---------------------------------------------------------------------------
-// mutateStream with no `final` — execute resolves with void (type-level)
+// mutateToResult with no `final` — execute resolves with void (type-level)
 // ---------------------------------------------------------------------------
 
-it.skip("mutateStream without final: execute resolves void (type-level)", () => {
+it.skip("mutateToResult without final: execute resolves void (type-level)", () => {
   const { clientFor } = useClient()
   const client = clientFor(Something, undefined, somethingInvalidationResources)
 
-  const execute = client.StreamWithoutFinal.mutateStream()
+  const execute = client.StreamWithoutFinal.mutateToResult()
 
   // execute returns void — assigning to ExportComplete Effect should fail
   const result = execute({ id: "test" })
@@ -57,14 +57,14 @@ it.skip("mutateStream without final: execute resolves void (type-level)", () =>
 })
 
 // ---------------------------------------------------------------------------
-// mutateStream with `final` — execute resolves with Final type (type-level)
+// mutateToResult with `final` — execute resolves with Final type (type-level)
 // ---------------------------------------------------------------------------
 
-it.skip("mutateStream with final: execute resolves with ExportComplete (type-level)", () => {
+it.skip("mutateToResult with final: execute resolves with ExportComplete (type-level)", () => {
   const { clientFor } = useClient()
   const client = clientFor(Something, undefined, somethingInvalidationResources)
 
-  const execute = client.StreamWithFinal.mutateStream()
+  const execute = client.StreamWithFinal.mutateToResult()
 
   // execute returns ExportComplete — assignment should compile cleanly
   const result = execute({ id: "test" })