effective-progress 0.2.0 → 0.2.1

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/effective-progress)](https://www.npmjs.com/package/effective-progress)
 
 > [!WARNING]
-> Pre-`1.0.0`, breaking changes may happen in any release. SemVer guarantees will begin at `1.0.0`.
+> Pre-`1.0.0`, breaking changes may happen in any release. SemVer guarantees will begin at `1.0.0`.  
 > I recommend using only the `Progress.all` and `Progress.forEach` APIs for now, as they will likely change the least. The lower-level APIs for manual progress bar control are more likely to see breaking changes as I iterate on the design.
 >
 > Please open an issue or reach out if you have any questions or want to contribute!
@@ -115,6 +115,25 @@ const configured = program.pipe(
 Effect.runPromise(configured);
 ```
 
+Task-level `progressbar` config is optional and inherits from its parent task (or from global `ProgressBarConfig` for root tasks):
+
+```ts
+yield *
+  progress.withTask(
+    Effect.sleep("1 second"),
+    {
+      description: "Worker pipeline",
+      progressbar: {
+        barWidth: 20,
+        spinnerFrames: [".", "o", "O", "0"],
+        colors: {
+          spinner: { kind: "named", value: "magentaBright" },
+        },
+      },
+    },
+  );
+```
+
 ## Terminal service and mocking
 
 `effective-progress` now exposes a `ProgressTerminal` service that controls terminal detection and I/O:
@@ -125,7 +144,7 @@ Effect.runPromise(configured);
 - `writeStderr(text)`
 - `withRawInputCapture(effect)`
 
-You can provide a mock in tests instead of monkeypatching global process streams:
+You can provide a mock if you want to alter the behavior of terminal detection or if you want to capture the output for testing:
 
 ```ts
 import { Effect } from "effect";
@@ -139,45 +158,23 @@ const mockTerminal: Progress.ProgressTerminalService = {
   withRawInputCapture: (effect) => effect,
 };
 
-const program = Progress.withTask({ description: "work" }, Effect.sleep("100 millis")).pipe(
+const program = Progress.withTask(Effect.sleep("100 millis"), { description: "work" }).pipe(
   Effect.provideService(Progress.ProgressTerminal, mockTerminal),
 );
 ```
 
-## Migration note
-
-`RendererConfig.isTTY` has been removed.
-TTY mode is now sourced from `ProgressTerminal.isTTY`.
-
-Task-level `progressbar` config is optional and inherits from its parent task (or from global `ProgressBarConfig` for root tasks):
-
-```ts
-yield *
-  progress.withTask(
-    {
-      description: "Worker pipeline",
-      progressbar: {
-        barWidth: 20,
-        spinnerFrames: [".", "o", "O", "0"],
-        colors: {
-          spinner: { kind: "named", value: "magentaBright" },
-        },
-      },
-    },
-    Effect.sleep("1 second"),
-  );
-```
+## Manual task control
 
 For manual usage, `withTask` captures logs implicitly and provides the current `Task` context:
 
 ```ts
 const program = Progress.withTask(
-  { description: "Manual task" },
   Effect.gen(function* () {
     const currentTask = yield* Progress.Task;
     yield* Console.log("This log is rendered through progress output", { taskId: currentTask });
     yield* Effect.sleep("1 second");
   }),
+  { description: "Manual task" },
 );
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effective-progress",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {

package/src/api.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { dual } from "effect/Function";
 import type { Concurrency } from "effect/Types";
 import { Progress, provideProgressService } from "./runtime";
 import { Task } from "./types";
@@ -31,81 +32,113 @@ export interface ForEachExecutionOptions extends EffectExecutionOptions {
 
 export type ForEachOptions = TrackOptions & ForEachExecutionOptions;
 
-export const withTask = <A, E, R>(
-  options: AddTaskOptions,
-  effect: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, Exclude<R, Progress | Task>> =>
+export const withTask: {
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+    options: AddTaskOptions,
+  ): Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+  <A, E, R>(
+    options: AddTaskOptions,
+  ): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+} = dual(2, <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
   provideProgressService(
     Effect.gen(function* () {
       const progress = yield* Progress;
-      return yield* progress.withTask(options, effect);
+      return yield* progress.withTask(effect, options);
     }),
-  ) as Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+  ) as Effect.Effect<A, E, Exclude<R, Progress | Task>>,
+);
 
-export const all = <
-  const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
-  O extends EffectAllExecutionOptions,
->(
-  effects: Arg,
-  options: Omit<TrackOptions, "total"> & O,
-): AllReturn<Arg, O> =>
-  provideProgressService(
-    Effect.gen(function* () {
-      const progress = yield* Progress;
-      return yield* progress.withTask(
-        {
-          description: options.description,
-          total: effects.length,
-          transient: options.transient,
-          progressbar: options.progressbar,
-        },
-        Effect.gen(function* () {
-          const taskId = yield* Task;
-          return yield* Effect.all(
-            effects.map((effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))),
-            {
-              concurrency: options.concurrency,
-              batching: options.batching,
-              discard: options.discard,
-              mode: options.mode,
-              concurrentFinalizers: options.concurrentFinalizers,
-            },
-          );
-        }),
-      );
-    }),
-  ) as AllReturn<Arg, O>;
+export const all: {
+  <const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>, O extends EffectAllExecutionOptions>(
+    effects: Arg,
+    options: Omit<TrackOptions, "total"> & O,
+  ): AllReturn<Arg, O>;
+  <O extends EffectAllExecutionOptions>(
+    options: Omit<TrackOptions, "total"> & O,
+  ): <const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>>(effects: Arg) => AllReturn<
+    Arg,
+    O
+  >;
+} = dual(
+  2,
+  <const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>, O extends EffectAllExecutionOptions>(
+    effects: Arg,
+    options: Omit<TrackOptions, "total"> & O,
+  ) =>
+    provideProgressService(
+      Effect.gen(function* () {
+        const progress = yield* Progress;
+        return yield* progress.withTask(
+          Effect.gen(function* () {
+            const taskId = yield* Task;
+            return yield* Effect.all(
+              effects.map((effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))),
+              {
+                concurrency: options.concurrency,
+                batching: options.batching,
+                discard: options.discard,
+                mode: options.mode,
+                concurrentFinalizers: options.concurrentFinalizers,
+              },
+            );
+          }),
+          {
+            description: options.description,
+            total: effects.length,
+            transient: options.transient,
+            progressbar: options.progressbar,
+          },
+        );
+      }),
+    ) as AllReturn<Arg, O>,
+);
 
-export const forEach = <A, B, E, R>(
-  iterable: Iterable<A>,
-  f: (item: A, index: number) => Effect.Effect<B, E, R>,
-  options: ForEachOptions,
-): Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>> =>
-  provideProgressService(
-    Effect.gen(function* () {
-      const progress = yield* Progress;
+export const forEach: {
+  <A, B, E, R>(
+    iterable: Iterable<A>,
+    f: (item: A, index: number) => Effect.Effect<B, E, R>,
+    options: ForEachOptions,
+  ): Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
+  <A, B, E, R>(
+    f: (item: A, index: number) => Effect.Effect<B, E, R>,
+    options: ForEachOptions,
+  ): (
+    iterable: Iterable<A>,
+  ) => Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
+} = dual(
+  3,
+  <A, B, E, R>(
+    iterable: Iterable<A>,
+    f: (item: A, index: number) => Effect.Effect<B, E, R>,
+    options: ForEachOptions,
+  ) =>
+    provideProgressService(
+      Effect.gen(function* () {
+        const progress = yield* Progress;
 
-      return yield* progress.withTask(
-        {
-          description: options.description,
-          total: options.total ?? inferTotal(iterable),
-          transient: options.transient,
-          progressbar: options.progressbar,
-        },
-        Effect.gen(function* () {
-          const taskId = yield* Task;
-          return yield* Effect.forEach(
-            iterable,
-            (item, index) =>
-              Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)),
-            {
-              concurrency: options.concurrency,
-              batching: options.batching,
-              discard: options.discard,
-              concurrentFinalizers: options.concurrentFinalizers,
-            },
-          );
-        }),
-      );
-    }),
-  ) as Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
+        return yield* progress.withTask(
+          Effect.gen(function* () {
+            const taskId = yield* Task;
+            return yield* Effect.forEach(
+              iterable,
+              (item, index) =>
+                Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)),
+              {
+                concurrency: options.concurrency,
+                batching: options.batching,
+                discard: options.discard,
+                concurrentFinalizers: options.concurrentFinalizers,
+              },
+            );
+          }),
+          {
+            description: options.description,
+            total: options.total ?? inferTotal(iterable),
+            transient: options.transient,
+            progressbar: options.progressbar,
+          },
+        );
+      }),
+    ) as Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>,
+);

package/src/runtime.ts

@@ -1,4 +1,5 @@
 import { Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
+import { dual } from "effect/Function";
 import { mergeWith } from "es-toolkit/object";
 import { formatWithOptions } from "node:util";
 import type { PartialDeep } from "type-fest";
@@ -275,6 +276,7 @@ const makeProgressService = Effect.gen(function* () {
         return;
       }
 
+      // TODO: Might wanna replace this or make it configurable. Look for other options.
       const message = formatWithOptions(
         {
           colors: isTTY,
@@ -297,66 +299,66 @@ const makeProgressService = Effect.gen(function* () {
       yield* markDirty;
     });
 
-  const log = (...args: ReadonlyArray<unknown>) =>
-    Effect.gen(function* () {
-      yield* appendLog(args);
-    });
+  const log = (...args: ReadonlyArray<unknown>) => appendLog(args);
 
   const getTask = (taskId: TaskId) =>
     Ref.get(tasksRef).pipe(Effect.map((tasks) => Option.fromNullable(tasks.get(taskId))));
 
   const listTasks = Ref.get(tasksRef).pipe(Effect.map((tasks) => Array.from(tasks.values())));
 
-  const withTask: ProgressService["withTask"] = (options, effect) =>
-    Effect.gen(function* () {
-      const outerConsole = yield* Effect.console;
-      const inheritedParentId = yield* FiberRef.get(currentParentRef);
-      const resolvedParentId =
-        options.parentId === undefined ? inheritedParentId : Option.some(options.parentId);
-
-      const taskId = yield* addTask({
-        ...options,
-        parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : undefined,
-        transient: options.transient ?? Option.isSome(resolvedParentId),
-      });
+  const withTask: ProgressService["withTask"] = dual(
+    2,
+    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
+      Effect.gen(function* () {
+        const outerConsole = yield* Effect.console;
+        const inheritedParentId = yield* FiberRef.get(currentParentRef);
+        const resolvedParentId =
+          options.parentId === undefined ? inheritedParentId : Option.some(options.parentId);
+
+        const taskId = yield* addTask({
+          ...options,
+          parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : undefined,
+          transient: options.transient ?? Option.isSome(resolvedParentId),
+        });
 
-      const exit = yield* Effect.exit(
-        Effect.locally(
-          Effect.withConsole(
-            Effect.provideService(effect, Task, taskId),
-            makeProgressConsole(log, outerConsole),
+        const exit = yield* Effect.exit(
+          Effect.locally(
+            Effect.withConsole(
+              Effect.provideService(effect, Task, taskId),
+              makeProgressConsole(log, outerConsole),
+            ),
+            currentParentRef,
+            Option.some(taskId),
           ),
-          currentParentRef,
-          Option.some(taskId),
-        ),
-      );
+        );
 
-      if (Exit.isSuccess(exit)) {
-        yield* completeTask(taskId);
-      } else {
-        yield* failTask(taskId);
-      }
+        if (Exit.isSuccess(exit)) {
+          yield* completeTask(taskId);
+        } else {
+          yield* failTask(taskId);
+        }
 
-      return yield* Exit.match(exit, {
-        onFailure: Effect.failCause,
-        onSuccess: Effect.succeed,
-      });
-    });
+        return yield* Exit.match(exit, {
+          onFailure: Effect.failCause,
+          onSuccess: Effect.succeed,
+        });
+      }),
+  );
 
   const trackIterable: ProgressService["trackIterable"] = (iterable, options, f) =>
     withTask(
-      {
-        description: options.description,
-        total: options.total ?? inferTotal(iterable),
-        transient: options.transient,
-        progressbar: options.progressbar,
-      },
       Effect.gen(function* () {
         const taskId = yield* Task;
         return yield* Effect.forEach(iterable, (item, index) =>
           Effect.tap(f(item, index), () => advanceTask(taskId, 1)),
         );
       }),
+      {
+        description: options.description,
+        total: options.total ?? inferTotal(iterable),
+        transient: options.transient,
+        progressbar: options.progressbar,
+      },
     );
 
   const service: ProgressService = {

package/src/types.ts

@@ -114,10 +114,15 @@ export interface ProgressService {
   readonly log: (...args: ReadonlyArray<unknown>) => Effect.Effect<void>;
   readonly getTask: (taskId: TaskId) => Effect.Effect<Option.Option<TaskSnapshot>>;
   readonly listTasks: Effect.Effect<ReadonlyArray<TaskSnapshot>>;
-  readonly withTask: <A, E, R>(
-    options: AddTaskOptions,
-    effect: Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E, Exclude<R, Task>>;
+  readonly withTask: {
+    <A, E, R>(
+      effect: Effect.Effect<A, E, R>,
+      options: AddTaskOptions,
+    ): Effect.Effect<A, E, Exclude<R, Task>>;
+    <A, E, R>(
+      options: AddTaskOptions,
+    ): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Task>>;
+  };
   readonly trackIterable: <A, B, E, R>(
     iterable: Iterable<A>,
     options: TrackOptions,