effective-progress 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effective-progress",
-  "version": "0.2.3",
+  "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/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 {