effective-progress 0.2.2 → 0.2.4

package/README.md

@@ -212,7 +212,7 @@ Supported modifiers:
 
 ## Dependencies & package size
 
-This library is designed for CLI workflows, where package size is typically a lower-priority concern. Alongside `effect`, it relies on two mature runtime dependencies: `chalk` and `es-toolkit`.
+This library is designed for CLI workflows, where package size is typically a lower-priority concern. Alongside `effect` though, I will strive to only rely on other high quality packages.
 
 ## Notes
 

package/package.json

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

package/src/api.ts

@@ -19,11 +19,15 @@ export interface EffectAllExecutionOptions extends EffectExecutionOptions {
 
 export type AllOptions = Omit<TrackOptions, "total"> & EffectAllExecutionOptions;
 export type AllReturn<
-  Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
+  Arg extends ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>,
   O extends EffectAllExecutionOptions,
-> = [Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>>] extends [
-  Effect.Effect<infer A, infer E, infer R>,
-]
+> = [
+  [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;
 
@@ -52,25 +56,30 @@ export const task: {
     ) as Effect.Effect<A, E, Exclude<R, Progress | Task>>,
 );
 
+type AllArg = ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>;
+
+const wrapEffects = (
+  effects: AllArg,
+  tap: (effect: Effect.Effect<any, any, any>) => Effect.Effect<any, any, any>,
+): AllArg =>
+  Array.isArray(effects)
+    ? effects.map(tap)
+    : Object.fromEntries(Object.entries(effects).map(([k, effect]) => [k, tap(effect)]));
+
+const countEffects = (effects: AllArg): number =>
+  Array.isArray(effects) ? effects.length : Object.keys(effects).length;
+
 export const all: {
-  <
-    const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
-    O extends EffectAllExecutionOptions,
-  >(
+  <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 ReadonlyArray<Effect.Effect<any, any, any>>>(
-    effects: Arg,
-  ) => AllReturn<Arg, O>;
+  ): <const Arg extends AllArg>(effects: Arg) => AllReturn<Arg, O>;
 } = dual(
   2,
-  <
-    const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
-    O extends EffectAllExecutionOptions,
-  >(
+  <const Arg extends AllArg, O extends EffectAllExecutionOptions>(
     effects: Arg,
     options: Omit<TrackOptions, "total"> & O,
   ) =>
@@ -82,7 +91,9 @@ export const all: {
             const taskId = yield* Task;
             const exit = yield* Effect.exit(
               Effect.all(
-                effects.map((effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))),
+                wrapEffects(effects, (effect) =>
+                  Effect.tap(effect, () => progress.advanceTask(taskId, 1)),
+                ),
                 {
                   concurrency: options.concurrency,
                   batching: options.batching,
@@ -106,7 +117,7 @@ export const all: {
           }),
           {
             description: options.description,
-            total: effects.length,
+            total: countEffects(effects),
             transient: options.transient,
             progressbar: options.progressbar,
           },

package/src/colors.ts

@@ -104,10 +104,10 @@ export const defaultProgressBarColors: ProgressBarColors = {
 };
 
 const applyModifier = (instance: ChalkInstance, modifier: StyleModifier): ChalkInstance =>
-  instance[modifier] as ChalkInstance;
+  instance[modifier];
 
 const applyNamedColor = (instance: ChalkInstance, color: NamedColor): ChalkInstance =>
-  instance[color] as ChalkInstance;
+  instance[color];
 
 const resolveBaseStyle = (style: ColorStyle): ChalkInstance => {
   switch (style.kind) {

package/src/renderer.ts

@@ -1,4 +1,4 @@
-import { Effect, Ref, Schema } from "effect";
+import { Clock, Duration, Effect, Ref, Schema } from "effect";
 import {
   type CompiledProgressBarColors,
   compileProgressBarColors,
@@ -27,34 +27,45 @@ const renderDeterminate = (
   return `${colors.brackets(progressbar.leftBracket)}${bar}${colors.brackets(progressbar.rightBracket)} ${units.completed}/${units.total} ${colors.percent(percent + "%")}`;
 };
 
+const formatElapsed = (snapshot: TaskSnapshot, now: number): string => {
+  const elapsedMillis = (snapshot.completedAt ?? now) - snapshot.startedAt;
+  const duration =
+    snapshot.status === "running"
+      ? Duration.seconds(Math.floor(elapsedMillis / 1000))
+      : Duration.millis(elapsedMillis);
+  return ` (${Duration.format(duration)})`;
+};
+
 const buildTaskLine = (
   snapshot: TaskSnapshot,
   depth: number,
   tick: number,
   colors: CompiledProgressBarColors,
+  now: number,
 ): string => {
   const progressbar = snapshot.config;
   const prefix = `${"  ".repeat(depth)}- ${snapshot.description}: `;
+  const elapsed = formatElapsed(snapshot, now);
 
   if (snapshot.status === "failed") {
-    return `${prefix}${colors.failed("[failed]")}`;
+    return `${prefix}${colors.failed("[failed]")}${elapsed}`;
   }
 
   if (snapshot.status === "done") {
     if (snapshot.units._tag === "DeterminateTaskUnits") {
-      return `${prefix}${colors.done("[done]")} ${snapshot.units.completed}/${snapshot.units.total}`;
+      return `${prefix}${colors.done("[done]")} ${snapshot.units.completed}/${snapshot.units.total}${elapsed}`;
     }
-    return `${prefix}${colors.done("[done]")}`;
+    return `${prefix}${colors.done("[done]")}${elapsed}`;
   }
 
   if (snapshot.units._tag === "DeterminateTaskUnits") {
-    return prefix + renderDeterminate(snapshot.units, progressbar, colors);
+    return prefix + renderDeterminate(snapshot.units, progressbar, colors) + elapsed;
   }
 
   const frames = progressbar.spinnerFrames;
   const frameIndex = (snapshot.units.spinnerFrame + tick) % frames.length;
   const frame = frames[frameIndex] ?? frames[0]!;
-  return `${prefix}${colors.spinner(frame)}`;
+  return `${prefix}${colors.spinner(frame)}${elapsed}`;
 };
 
 export const runProgressServiceRenderer = (
@@ -170,10 +181,11 @@ export const runProgressServiceRenderer = (
         if (!snapshot || (snapshot.transient && snapshot.status !== "running")) return [];
         return [{ snapshot, depth: row.depth }];
       });
+      const now = yield* Clock.currentTimeMillis;
       const frameTick = mode === "final" ? tick + 1 : tick;
       const taskLines = ordered.map(({ snapshot, depth }) => {
         const lineTick = isTTY ? frameTick : 0;
-        return buildTaskLine(snapshot, depth, lineTick, getCompiledColors(snapshot.config));
+        return buildTaskLine(snapshot, depth, lineTick, getCompiledColors(snapshot.config), now);
       });
 
       if (isTTY) {

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import { Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
+import { Clock, 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";
@@ -82,6 +82,8 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
     transient: options.transient ?? snapshot.transient,
     units,
     config: snapshot.config,
+    startedAt: snapshot.startedAt,
+    completedAt: snapshot.completedAt,
   });
 };
 
@@ -181,6 +183,7 @@ const makeProgressService = Effect.gen(function* () {
         mergeConfig(inheritedProgressBarConfig, options.progressbar),
       );
 
+      const now = yield* Clock.currentTimeMillis;
       const parentIdValue = Option.getOrNull(resolvedParentId);
       const snapshot = new TaskSnapshot({
         id: taskId,
@@ -190,6 +193,8 @@ const makeProgressService = Effect.gen(function* () {
         transient: options.transient ?? false,
         units,
         config: resolvedProgressBarConfig,
+        startedAt: now,
+        completedAt: null,
       });
 
       yield* Ref.update(storeRef, (s) => {
@@ -240,6 +245,8 @@ const makeProgressService = Effect.gen(function* () {
           transient: snapshot.transient,
           units,
           config: snapshot.config,
+          startedAt: snapshot.startedAt,
+          completedAt: snapshot.completedAt,
         }),
       );
 
@@ -247,62 +254,74 @@ const makeProgressService = Effect.gen(function* () {
     }).pipe(Effect.zipRight(markDirty));
 
   const completeTask = (taskId: TaskId) =>
-    Ref.update(storeRef, (store) => {
-      const snapshot = store.tasks.get(taskId);
-      if (!snapshot) return store;
-
-      const nextTasks = new Map(store.tasks);
-      if (snapshot.transient) {
-        nextTasks.delete(taskId);
-        return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
-      }
-
-      nextTasks.set(
-        taskId,
-        new TaskSnapshot({
-          id: snapshot.id,
-          parentId: snapshot.parentId,
-          description: snapshot.description,
-          status: "done",
-          transient: snapshot.transient,
-          units:
-            snapshot.units._tag === "DeterminateTaskUnits"
-              ? new DeterminateTaskUnits({
-                  completed: snapshot.units.total,
-                  total: snapshot.units.total,
-                })
-              : snapshot.units,
-          config: snapshot.config,
-        }),
-      );
-      return { tasks: nextTasks, renderOrder: store.renderOrder };
-    }).pipe(Effect.zipRight(markDirty));
+    Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis;
+      yield* Ref.update(storeRef, (store) => {
+        const snapshot = store.tasks.get(taskId);
+        if (!snapshot) return store;
+
+        const nextTasks = new Map(store.tasks);
+        if (snapshot.transient) {
+          nextTasks.delete(taskId);
+          return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
+        }
+
+        nextTasks.set(
+          taskId,
+          new TaskSnapshot({
+            id: snapshot.id,
+            parentId: snapshot.parentId,
+            description: snapshot.description,
+            status: "done",
+            transient: snapshot.transient,
+            units:
+              snapshot.units._tag === "DeterminateTaskUnits"
+                ? new DeterminateTaskUnits({
+                    completed: snapshot.units.total,
+                    total: snapshot.units.total,
+                  })
+                : snapshot.units,
+            config: snapshot.config,
+            startedAt: snapshot.startedAt,
+            completedAt: now,
+          }),
+        );
+        return { tasks: nextTasks, renderOrder: store.renderOrder };
+      });
+      yield* markDirty;
+    });
 
   const failTask = (taskId: TaskId) =>
-    Ref.update(storeRef, (store) => {
-      const snapshot = store.tasks.get(taskId);
-      if (!snapshot) return store;
-
-      const nextTasks = new Map(store.tasks);
-      if (snapshot.transient) {
-        nextTasks.delete(taskId);
-        return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
-      }
-
-      nextTasks.set(
-        taskId,
-        new TaskSnapshot({
-          id: snapshot.id,
-          parentId: snapshot.parentId,
-          description: snapshot.description,
-          status: "failed",
-          transient: snapshot.transient,
-          units: snapshot.units,
-          config: snapshot.config,
-        }),
-      );
-      return { tasks: nextTasks, renderOrder: store.renderOrder };
-    }).pipe(Effect.zipRight(markDirty));
+    Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis;
+      yield* Ref.update(storeRef, (store) => {
+        const snapshot = store.tasks.get(taskId);
+        if (!snapshot) return store;
+
+        const nextTasks = new Map(store.tasks);
+        if (snapshot.transient) {
+          nextTasks.delete(taskId);
+          return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
+        }
+
+        nextTasks.set(
+          taskId,
+          new TaskSnapshot({
+            id: snapshot.id,
+            parentId: snapshot.parentId,
+            description: snapshot.description,
+            status: "failed",
+            transient: snapshot.transient,
+            units: snapshot.units,
+            config: snapshot.config,
+            startedAt: snapshot.startedAt,
+            completedAt: now,
+          }),
+        );
+        return { tasks: nextTasks, renderOrder: store.renderOrder };
+      });
+      yield* markDirty;
+    });
 
   const appendLog = (args: ReadonlyArray<unknown>) =>
     Effect.gen(function* () {

package/src/types.ts

@@ -25,7 +25,7 @@ export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarC
 
 export const defaultRendererConfig: RendererConfigShape = {
   disableUserInput: true,
-  renderIntervalMillis: 50, // 20 FPS
+  renderIntervalMillis: 100, // 10 FPS
   maxLogLines: 0,
   nonTtyUpdateStep: 5,
 };
@@ -103,6 +103,8 @@ export class TaskSnapshot extends Schema.TaggedClass<TaskSnapshot>()("TaskSnapsh
   transient: Schema.Boolean,
   units: TaskUnitsSchema,
   config: ProgressBarConfigSchema,
+  startedAt: Schema.Number,
+  completedAt: Schema.NullOr(Schema.Number),
 }) {}
 
 export interface RenderRow {