effective-progress 0.5.3 → 0.6.0

package/README.md

@@ -11,7 +11,7 @@
 
 <img alt="Showcase output" src="docs/images/showcase.gif" width="600" />
 
-`effective-progress` is an [Effect](https://effect.website/)-first terminal progress-bar library with:
+`effective-progress` is an [Effect](https://effect.website/)-native CLI progress bar library with:
 
 - multiple nested tree-like progress bars
 - spinner support for “we have no idea how long this takes” work
@@ -79,10 +79,17 @@ Effect.runPromise(program);
 
 <img alt="Nested example output" src="docs/images/nesting.gif" width="600" />
 
+### Effect.all modes
+
+We support the `either`/`validate` modes of `Effect.all` and render the amount of sucesses/failures.
+
+<img alt="Mixed outcomes modes output" src="docs/images/mixedOutcomes.gif" width="600" />
+
 ### Other examples
 
 - `examples/simpleExample.ts` - low-boilerplate real-world flow
 - `examples/advancedExample.ts` - full API usage and manual task control
+- `examples/mixedOutcomes.ts` - fail-fast vs `either`/`validate` with mixed success/failure counters
 - `examples/showcase.ts` - nested concurrent tasks, spinner workloads, and mixed Effect/Console logging
 - `examples/performance.ts` - stress-style run with high log volume and deeply nested progress updates
 
@@ -98,11 +105,20 @@ Effect.runPromise(program);
 
 - Rendering is powered by [Ink](https://github.com/vadimdemedes/ink).
 - Built-in columns are: description, bar, amount/spinner, elapsed, and ETA.
+- Determinate bars are segmented by outcome: succeeded (green), failed (red), and remaining (neutral).
+- Determinate amount text shows counters without prefixes: `<succeeded> <failed> <processed>/<total>`.
 - Column widths are shared per frame (widest visible cell wins), so rows stay aligned.
 - Elapsed and ETA reserve stable widths to reduce jitter while tasks transition states.
 - Layout uses a 100-column baseline and grows when content requires more space.
 - On narrow terminals, layout compacts to fit available width and tree prefixes are suppressed when description space is too tight.
 
+### Mixed outcomes and `mode`
+
+- `Progress.all` in default mode (`mode: "default"`) remains fail-fast.
+- In fail-fast runs, unresolved units remain unprocessed.
+- `mode: "either"` and `mode: "validate"` run all effects and keep mixed outcomes in the task counters.
+- Mixed outcomes can still finalize as `done` when all units are accounted for.
+
 ## Manual task control
 
 For manual usage, `task` still provides the current `Task` context, while logs continue through your outer `Console`:
@@ -110,11 +126,16 @@ For manual usage, `task` still provides the current `Task` context, while logs c
 ```ts
 const program = Progress.task(
   Effect.gen(function* () {
+    const progress = yield* Progress.Progress;
     const currentTask = yield* Progress.Task;
     yield* Console.log("This log is handled by the outer Console", { taskId: currentTask });
+
+    // Manual determinate updates:
+    yield* progress.advanceTask(currentTask, 3);
+    yield* progress.advanceTaskFailed(currentTask, 1);
     yield* Effect.sleep("1 second");
   }),
-  { description: "Manual task" },
+  { description: "Manual task", total: 10 },
 );
 ```
 
@@ -122,35 +143,6 @@ const program = Progress.task(
 
 Custom column APIs are not part of the first Ink release. The renderer ships with built-in columns only, and old renderer config APIs (`RendererConfig`, `ProgressBarConfig`, custom column definitions) are intentionally removed in this iteration.
 
-## Terminal service and mocking
-
-`effective-progress` now exposes a `ProgressTerminal` service that controls terminal detection and I/O:
-
-- `isTTY`
-- `stderrRows`
-- `stderrColumns`
-- `writeStderr(text)`
-- `withRawInputCapture(effect)`
-
-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";
-import * as Progress from "effective-progress";
-
-const mockTerminal: Progress.ProgressTerminalService = {
-  isTTY: Effect.succeed(true),
-  stderrRows: Effect.succeed(40),
-  stderrColumns: Effect.succeed(120),
-  writeStderr: (_text) => Effect.void,
-  withRawInputCapture: (effect) => effect,
-};
-
-const program = Progress.task(Effect.sleep("100 millis"), { description: "work" }).pipe(
-  Effect.provideService(Progress.ProgressTerminal, mockTerminal),
-);
-```
-
 ## Notes
 
 - As Effect 4.0 is around the corner with some changes to logging, there may be some adjustments needed to align with the new Effect APIs.

package/dist/index.d.mts

@@ -8,30 +8,35 @@ type TaskId = typeof TaskIdSchema.Type;
 declare const TaskId: Brand.Brand.Constructor<number & Brand.Brand<"TaskId">>;
 declare const TaskStatusSchema: Schema.Literal<["running", "done", "failed"]>;
 type TaskStatus = typeof TaskStatusSchema.Type;
+declare const TaskCountDisplaySchema: Schema.Literal<["processedOnly", "detailed"]>;
+type TaskCountDisplay = typeof TaskCountDisplaySchema.Type;
 interface AddTaskOptions {
   readonly description: string;
   readonly total?: number;
   readonly transient?: boolean;
   readonly parentId?: TaskId;
+  readonly countDisplay?: TaskCountDisplay;
 }
 interface UpdateTaskOptions {
   readonly description?: string;
-  readonly completed?: number;
+  readonly succeeded?: number;
+  readonly failed?: number;
   readonly total?: number;
   readonly transient?: boolean;
+  readonly countDisplay?: TaskCountDisplay;
 }
 type TrackOptions = Exclude<AddTaskOptions, "parentId">;
 declare const DeterminateTaskUnits_base: Schema.TaggedClass<DeterminateTaskUnits, "DeterminateTaskUnits", {
   readonly _tag: Schema.tag<"DeterminateTaskUnits">;
 } & {
-  completed: typeof Schema.Number;
+  succeeded: typeof Schema.Number;
+  failed: typeof Schema.Number;
+  processed: typeof Schema.Number;
   total: typeof Schema.Number;
 }>;
 declare class DeterminateTaskUnits extends DeterminateTaskUnits_base {}
 declare const IndeterminateTaskUnits_base: Schema.TaggedClass<IndeterminateTaskUnits, "IndeterminateTaskUnits", {
   readonly _tag: Schema.tag<"IndeterminateTaskUnits">;
-} & {
-  spinnerFrame: typeof Schema.Number;
 }>;
 declare class IndeterminateTaskUnits extends IndeterminateTaskUnits_base {}
 declare const TaskUnitsSchema: Schema.Union<[typeof DeterminateTaskUnits, typeof IndeterminateTaskUnits]>;
@@ -43,6 +48,7 @@ declare const TaskSnapshot_base: Schema.TaggedClass<TaskSnapshot, "TaskSnapshot"
   parentId: Schema.NullOr<Schema.brand<typeof Schema.Number, "TaskId">>;
   description: typeof Schema.String;
   status: Schema.Literal<["running", "done", "failed"]>;
+  countDisplay: Schema.Literal<["processedOnly", "detailed"]>;
   transient: typeof Schema.Boolean;
   units: Schema.Union<[typeof DeterminateTaskUnits, typeof IndeterminateTaskUnits]>;
   startedAt: typeof Schema.Number;
@@ -61,6 +67,7 @@ interface ProgressService {
   readonly addTask: (options: AddTaskOptions) => Effect.Effect<TaskId>;
   readonly updateTask: (taskId: TaskId, options: UpdateTaskOptions) => Effect.Effect<void>;
   readonly advanceTask: (taskId: TaskId, amount?: number) => Effect.Effect<void>;
+  readonly advanceTaskFailed: (taskId: TaskId, amount?: number) => Effect.Effect<void>;
   readonly completeTask: (taskId: TaskId) => Effect.Effect<void>;
   readonly failTask: (taskId: TaskId) => Effect.Effect<void>;
   readonly log: (...args: ReadonlyArray<unknown>) => Effect.Effect<void>;
@@ -85,6 +92,7 @@ declare const TaskAddedEvent_base: Schema.TaggedClass<TaskAddedEvent, "TaskAdded
   description: typeof Schema.String;
   total: Schema.optional<typeof Schema.Number>;
   transient: typeof Schema.Boolean;
+  countDisplay: Schema.Literal<["processedOnly", "detailed"]>;
 }>;
 declare class TaskAddedEvent extends TaskAddedEvent_base {}
 declare const TaskUpdatedEvent_base: Schema.TaggedClass<TaskUpdatedEvent, "TaskUpdated", {
@@ -92,9 +100,12 @@ declare const TaskUpdatedEvent_base: Schema.TaggedClass<TaskUpdatedEvent, "TaskU
 } & {
   taskId: Schema.brand<typeof Schema.Number, "TaskId">;
   description: Schema.optional<typeof Schema.String>;
-  completed: Schema.optional<typeof Schema.Number>;
+  succeeded: Schema.optional<typeof Schema.Number>;
+  failed: Schema.optional<typeof Schema.Number>;
+  processed: Schema.optional<typeof Schema.Number>;
   total: Schema.optional<typeof Schema.Number>;
   transient: Schema.optional<typeof Schema.Boolean>;
+  countDisplay: Schema.optional<Schema.Literal<["processedOnly", "detailed"]>>;
 }>;
 declare class TaskUpdatedEvent extends TaskUpdatedEvent_base {}
 declare const TaskAdvancedEvent_base: Schema.TaggedClass<TaskAdvancedEvent, "TaskAdvanced", {
@@ -102,6 +113,7 @@ declare const TaskAdvancedEvent_base: Schema.TaggedClass<TaskAdvancedEvent, "Tas
 } & {
   taskId: Schema.brand<typeof Schema.Number, "TaskId">;
   amount: typeof Schema.Number;
+  kind: Schema.Literal<["succeeded", "failed"]>;
 }>;
 declare class TaskAdvancedEvent extends TaskAdvancedEvent_base {}
 declare const TaskCompletedEvent_base: Schema.TaggedClass<TaskCompletedEvent, "TaskCompleted", {
@@ -126,7 +138,7 @@ declare const ProgressTaskEventSchema: Schema.Union<[typeof TaskAddedEvent, type
 type ProgressTaskEvent = typeof ProgressTaskEventSchema.Type;
 declare const decodeProgressTaskEvent: (u: unknown, overrideOptions?: effect_SchemaAST0.ParseOptions) => TaskAddedEvent | TaskUpdatedEvent | TaskAdvancedEvent | TaskCompletedEvent | TaskFailedEvent | TaskRemovedEvent;
 //#endregion
-//#region src/runtime.d.ts
+//#region src/services/progress.d.ts
 declare const Progress_base: Context.TagClass<Progress, "stromseng.dev/effective-progress/Progress", ProgressService>;
 declare class Progress extends Progress_base {
   static readonly Default: Layer.Layer<Progress, never, never>;
@@ -142,12 +154,12 @@ interface EffectAllExecutionOptions extends EffectExecutionOptions {
   readonly discard?: boolean;
   readonly mode?: "default" | "validate" | "either";
 }
-type AllOptions = Omit<TrackOptions, "total"> & EffectAllExecutionOptions;
+type AllOptions = Omit<TrackOptions, "total" | "countDisplay"> & EffectAllExecutionOptions;
 type AllReturn<Arg extends ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>, O extends EffectAllExecutionOptions> = [[Arg] extends [ReadonlyArray<Effect.Effect<any, any, any>>] ? Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : [Arg] extends [Record<string, Effect.Effect<any, any, any>>] ? Effect.All.ReturnObject<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : never] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Exclude<R, Progress | Task>> : never;
 interface ForEachExecutionOptions extends EffectExecutionOptions {
   readonly discard?: false | undefined;
 }
-type ForEachOptions = TrackOptions & ForEachExecutionOptions;
+type ForEachOptions = Omit<TrackOptions, "countDisplay"> & ForEachExecutionOptions;
 type TaskOptions = AddTaskOptions;
 declare const task: {
   <A, E, R>(effect: Effect.Effect<A, E, R>, options: TaskOptions): Effect.Effect<A, E, Exclude<R, Progress | Task>>;
@@ -155,25 +167,22 @@ declare const task: {
 };
 type AllArg = ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>;
 declare const all: {
-  <const Arg extends AllArg, O extends EffectAllExecutionOptions>(effects: Arg, options: Omit<TrackOptions, "total"> & O): AllReturn<Arg, O>;
-  <O extends EffectAllExecutionOptions>(options: Omit<TrackOptions, "total"> & O): <const Arg extends AllArg>(effects: Arg) => AllReturn<Arg, O>;
+  <const Arg extends AllArg, O extends EffectAllExecutionOptions>(effects: Arg, options: Omit<TrackOptions, "total" | "countDisplay"> & O): AllReturn<Arg, O>;
+  <O extends EffectAllExecutionOptions>(options: Omit<TrackOptions, "total" | "countDisplay"> & O): <const Arg extends AllArg>(effects: Arg) => AllReturn<Arg, O>;
 };
 declare 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>>;
 };
 //#endregion
-//#region src/terminal.d.ts
-interface ProgressTerminalService {
-  readonly isTTY: Effect.Effect<boolean>;
-  readonly stderrRows: Effect.Effect<number | undefined>;
-  readonly stderrColumns: Effect.Effect<number | undefined>;
-  readonly writeStderr: (text: string) => Effect.Effect<void>;
-  readonly withRawInputCapture: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+//#region src/services/stdio.d.ts
+interface ProgressStdioService {
+  readonly stdout: NodeJS.WriteStream;
+  readonly stderr: NodeJS.WriteStream;
 }
-declare const ProgressTerminal_base: Context.TagClass<ProgressTerminal, "stromseng.dev/ProgressTerminal", ProgressTerminalService>;
-declare class ProgressTerminal extends ProgressTerminal_base {
-  static readonly Default: Layer.Layer<ProgressTerminal, never, never>;
+declare const ProgressStdio_base: Context.TagClass<ProgressStdio, "stromseng.dev/effective-progress/ProgressStdio", ProgressStdioService>;
+declare class ProgressStdio extends ProgressStdio_base {
+  static readonly Default: Layer.Layer<ProgressStdio, never, never>;
 }
 //#endregion
-export { AddTaskOptions, AllOptions, AllReturn, DeterminateTaskUnits, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, IndeterminateTaskUnits, Progress, ProgressService, ProgressTaskEvent, ProgressTaskEventSchema, ProgressTerminal, ProgressTerminalService, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskId, TaskOptions, TaskRemovedEvent, TaskSnapshot, TaskStatus, TaskStatusSchema, TaskStore, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task };
+export { AddTaskOptions, AllOptions, AllReturn, DeterminateTaskUnits, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, IndeterminateTaskUnits, Progress, ProgressService, ProgressStdio, ProgressStdioService, ProgressTaskEvent, ProgressTaskEventSchema, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplay, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskOptions, TaskRemovedEvent, TaskSnapshot, TaskStatus, TaskStatusSchema, TaskStore, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task };