effective-progress 0.3.0 → 0.4.0

package/src/runtime.ts

@@ -3,10 +3,10 @@ import { dual } from "effect/Function";
 import { mergeWith } from "es-toolkit/object";
 import { formatWithOptions } from "node:util";
 import type { PartialDeep } from "type-fest";
-import { Colorizer, type ColorizerService } from "./colors";
 import { makeProgressConsole } from "./console";
-import { runProgressServiceRenderer } from "./renderer";
+import { BuildStage, ColorStage, FrameRenderer, ShrinkStage } from "./renderer";
 import { ProgressTerminal } from "./terminal";
+import { Theme, type ThemeService } from "./theme";
 import type {
   AddTaskOptions,
   ProgressService,
@@ -88,6 +88,19 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
   });
 };
 
+const withTransient = (snapshot: TaskSnapshot, transient: boolean): TaskSnapshot =>
+  new TaskSnapshot({
+    id: snapshot.id,
+    parentId: snapshot.parentId,
+    description: snapshot.description,
+    status: snapshot.status,
+    transient,
+    units: snapshot.units,
+    config: snapshot.config,
+    startedAt: snapshot.startedAt,
+    completedAt: snapshot.completedAt,
+  });
+
 const findInsertionIndex = (
   renderOrder: ReadonlyArray<RenderRow>,
   parentId: TaskId | null,
@@ -133,6 +146,7 @@ const makeProgressService = Effect.gen(function* () {
     ),
   );
   const terminal = yield* ProgressTerminal;
+  const frameRenderer = yield* FrameRenderer;
   const isTTY = yield* terminal.isTTY;
   const maxRetainedLogLines = Math.max(0, Math.floor(rendererConfig.maxLogLines ?? 0));
 
@@ -140,7 +154,7 @@ const makeProgressService = Effect.gen(function* () {
   const storeRef = yield* Ref.make<TaskStore>({
     tasks: new Map<TaskId, TaskSnapshot>(),
     renderOrder: [],
-    colorizers: new Map<TaskId, ColorizerService>(),
+    themes: new Map<TaskId, ThemeService>(),
   });
   const logsRef = yield* Ref.make<ReadonlyArray<string>>([]);
   const pendingLogsRef = yield* Ref.make<ReadonlyArray<string>>([]);
@@ -149,7 +163,7 @@ const makeProgressService = Effect.gen(function* () {
   const scope = yield* Effect.scope;
 
   yield* Effect.forkIn(
-    runProgressServiceRenderer(
+    frameRenderer.run({
       storeRef,
       logsRef,
       pendingLogsRef,
@@ -158,7 +172,7 @@ const makeProgressService = Effect.gen(function* () {
       isTTY,
       rendererConfig,
       maxRetainedLogLines,
-    ),
+    }),
     scope,
   );
 
@@ -170,7 +184,7 @@ const makeProgressService = Effect.gen(function* () {
         options.parentId === undefined
           ? yield* FiberRef.get(currentParentRef)
           : Option.some(options.parentId);
-      const colorizerOption = yield* Effect.serviceOption(Colorizer);
+      const themeOption = yield* Effect.serviceOption(Theme);
       const taskId = TaskId(yield* Ref.updateAndGet(nextTaskIdRef, (id) => id + 1));
       const units =
         options.total === undefined || options.total <= 0
@@ -192,7 +206,7 @@ const makeProgressService = Effect.gen(function* () {
         parentId: parentIdValue,
         description: options.description,
         status: "running",
-        transient: options.transient ?? false,
+        transient: parentSnapshot?.transient ?? options.transient ?? false,
         units,
         config: resolvedProgressBarConfig,
         startedAt: now,
@@ -205,11 +219,11 @@ const makeProgressService = Effect.gen(function* () {
         const { index, depth } = findInsertionIndex(s.renderOrder, parentIdValue);
         const nextOrder = [...s.renderOrder];
         nextOrder.splice(index, 0, { id: taskId, depth });
-        const nextColorizers = new Map(s.colorizers);
-        if (Option.isSome(colorizerOption)) {
-          nextColorizers.set(taskId, colorizerOption.value);
+        const nextThemes = new Map(s.themes);
+        if (Option.isSome(themeOption)) {
+          nextThemes.set(taskId, themeOption.value);
         }
-        return { tasks: nextTasks, renderOrder: nextOrder, colorizers: nextColorizers };
+        return { tasks: nextTasks, renderOrder: nextOrder, themes: nextThemes };
       });
       yield* markDirty;
 
@@ -221,8 +235,32 @@ const makeProgressService = Effect.gen(function* () {
       const snapshot = store.tasks.get(taskId);
       if (!snapshot) return store;
       const nextTasks = new Map(store.tasks);
-      nextTasks.set(taskId, updatedSnapshot(snapshot, options));
-      return { tasks: nextTasks, renderOrder: store.renderOrder, colorizers: store.colorizers };
+      const nextSnapshot = updatedSnapshot(snapshot, options);
+      nextTasks.set(taskId, nextSnapshot);
+
+      if (options.transient !== undefined) {
+        for (const [candidateId, candidate] of store.tasks.entries()) {
+          if (candidateId === taskId) {
+            continue;
+          }
+
+          let parentId = candidate.parentId;
+          let isDescendant = false;
+          while (parentId !== null) {
+            if (parentId === taskId) {
+              isDescendant = true;
+              break;
+            }
+            parentId = store.tasks.get(parentId)?.parentId ?? null;
+          }
+
+          if (isDescendant) {
+            nextTasks.set(candidateId, withTransient(candidate, nextSnapshot.transient));
+          }
+        }
+      }
+
+      return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
     }).pipe(Effect.zipRight(markDirty));
 
   const advanceTask = (taskId: TaskId, amount = 1) =>
@@ -256,7 +294,7 @@ const makeProgressService = Effect.gen(function* () {
         }),
       );
 
-      return { tasks: nextTasks, renderOrder: store.renderOrder, colorizers: store.colorizers };
+      return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
     }).pipe(Effect.zipRight(markDirty));
 
   const completeTask = (taskId: TaskId) =>
@@ -269,12 +307,12 @@ const makeProgressService = Effect.gen(function* () {
         const nextTasks = new Map(store.tasks);
         if (snapshot.transient) {
           nextTasks.delete(taskId);
-          const nextColorizers = new Map(store.colorizers);
-          nextColorizers.delete(taskId);
+          const nextThemes = new Map(store.themes);
+          nextThemes.delete(taskId);
           return {
             tasks: nextTasks,
             renderOrder: removeFromRenderOrder(store.renderOrder, taskId),
-            colorizers: nextColorizers,
+            themes: nextThemes,
           };
         }
 
@@ -298,7 +336,7 @@ const makeProgressService = Effect.gen(function* () {
             completedAt: now,
           }),
         );
-        return { tasks: nextTasks, renderOrder: store.renderOrder, colorizers: store.colorizers };
+        return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
       });
       yield* markDirty;
     });
@@ -313,12 +351,12 @@ const makeProgressService = Effect.gen(function* () {
         const nextTasks = new Map(store.tasks);
         if (snapshot.transient) {
           nextTasks.delete(taskId);
-          const nextColorizers = new Map(store.colorizers);
-          nextColorizers.delete(taskId);
+          const nextThemes = new Map(store.themes);
+          nextThemes.delete(taskId);
           return {
             tasks: nextTasks,
             renderOrder: removeFromRenderOrder(store.renderOrder, taskId),
-            colorizers: nextColorizers,
+            themes: nextThemes,
           };
         }
 
@@ -336,7 +374,7 @@ const makeProgressService = Effect.gen(function* () {
             completedAt: now,
           }),
         );
-        return { tasks: nextTasks, renderOrder: store.renderOrder, colorizers: store.colorizers };
+        return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
       });
       yield* markDirty;
     });
@@ -389,7 +427,7 @@ const makeProgressService = Effect.gen(function* () {
         const taskId = yield* addTask({
           ...options,
           parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : undefined,
-          transient: options.transient ?? Option.isSome(resolvedParentId),
+          transient: options.transient,
         });
 
         return yield* Effect.locally(
@@ -448,13 +486,34 @@ export class Progress extends Context.Tag("stromseng.dev/effective-progress/Prog
 >() {
   static readonly Default = Layer.unwrapEffect(
     Effect.gen(function* () {
-      const colorizerOption = yield* Effect.serviceOption(Colorizer);
+      const themeOption = yield* Effect.serviceOption(Theme);
       const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
-      const base = Layer.scoped(Progress, makeProgressService);
-      return base.pipe(
-        Option.isNone(colorizerOption) ? Layer.provide(Colorizer.Default) : (l) => l,
-        Option.isNone(terminalOption) ? Layer.provide(ProgressTerminal.Default) : (l) => l,
-      );
+      const buildStageOption = yield* Effect.serviceOption(BuildStage);
+      const shrinkStageOption = yield* Effect.serviceOption(ShrinkStage);
+      const colorStageOption = yield* Effect.serviceOption(ColorStage);
+      const frameRendererOption = yield* Effect.serviceOption(FrameRenderer);
+      let layer: Layer.Layer<Progress, never, any> = Layer.scoped(Progress, makeProgressService);
+
+      if (Option.isNone(frameRendererOption)) {
+        layer = layer.pipe(Layer.provide(FrameRenderer.Default));
+      }
+      if (Option.isNone(colorStageOption)) {
+        layer = layer.pipe(Layer.provide(ColorStage.Default));
+      }
+      if (Option.isNone(shrinkStageOption)) {
+        layer = layer.pipe(Layer.provide(ShrinkStage.Default));
+      }
+      if (Option.isNone(buildStageOption)) {
+        layer = layer.pipe(Layer.provide(BuildStage.Default));
+      }
+      if (Option.isNone(themeOption)) {
+        layer = layer.pipe(Layer.provide(Theme.Default));
+      }
+      if (Option.isNone(terminalOption)) {
+        layer = layer.pipe(Layer.provide(ProgressTerminal.Default));
+      }
+
+      return layer as Layer.Layer<Progress, never, never>;
     }),
   );
 }

package/src/theme.ts

@@ -0,0 +1,87 @@
+import chalk, { type ChalkInstance } from "chalk";
+import { Context, Effect, Layer } from "effect";
+
+export type ThemeRole =
+  | "plain"
+  | "barFill"
+  | "barEmpty"
+  | "barBracket"
+  | "spinner"
+  | "statusDone"
+  | "statusFailed"
+  | "text"
+  | "units"
+  | "eta"
+  | "elapsed"
+  | "treeConnector";
+
+export type ThemeStyle = (text: string) => string;
+
+export interface ThemeService {
+  readonly styles: Readonly<Record<ThemeRole, ThemeStyle>>;
+  readonly depthPalette?: (depth: number, role: ThemeRole) => ThemeStyle | undefined;
+}
+
+export class Theme extends Context.Tag("stromseng.dev/effective-progress/Theme")<
+  Theme,
+  ThemeService
+>() {
+  static readonly Default = Layer.succeed(
+    Theme,
+    Theme.of({
+      styles: {
+        plain: (text) => text,
+        barFill: chalk.blue,
+        barEmpty: chalk.white.dim,
+        barBracket: chalk.white.dim,
+        spinner: chalk.yellow,
+        statusDone: chalk.green,
+        statusFailed: chalk.red,
+        text: (text) => text,
+        units: chalk.whiteBright,
+        eta: chalk.gray,
+        elapsed: chalk.gray,
+        treeConnector: chalk.gray,
+      },
+    }),
+  );
+
+  static readonly Rainbow = Layer.unwrapEffect(
+    Effect.gen(function* () {
+      let colorNumber = 17;
+      yield* Effect.fork(
+        Effect.gen(function* () {
+          while (true) {
+            colorNumber = (colorNumber + 1) % 256;
+            yield* Effect.sleep("200 millis");
+          }
+        }),
+      );
+
+      const dynamic =
+        (instance: ChalkInstance): ThemeStyle =>
+        (text) =>
+          instance.ansi256(colorNumber)(text);
+
+      return Layer.succeed(
+        Theme,
+        Theme.of({
+          styles: {
+            plain: (text) => text,
+            barFill: dynamic(chalk),
+            barEmpty: dynamic(chalk.dim),
+            barBracket: dynamic(chalk),
+            spinner: dynamic(chalk),
+            statusDone: dynamic(chalk.bold),
+            statusFailed: dynamic(chalk.bold),
+            text: dynamic(chalk),
+            units: dynamic(chalk),
+            eta: dynamic(chalk),
+            elapsed: dynamic(chalk),
+            treeConnector: dynamic(chalk),
+          },
+        }),
+      );
+    }),
+  );
+}

package/src/types.ts

@@ -1,12 +1,14 @@
 import { Brand, Context, Effect, Option, Schema } from "effect";
 import type { PartialDeep } from "type-fest";
-import type { ColorizerService } from "./colors";
+import type { ThemeService } from "./theme";
 
 export const RendererConfigSchema = Schema.Struct({
   disableUserInput: Schema.Boolean,
   renderIntervalMillis: Schema.Number,
   maxLogLines: Schema.optional(Schema.Number),
   nonTtyUpdateStep: Schema.Number,
+  determinateTaskLayout: Schema.Literal("single-line", "two-lines"),
+  maxTaskWidth: Schema.optional(Schema.Number),
 });
 export type RendererConfigShape = typeof RendererConfigSchema.Type;
 export const decodeRendererConfigSync = Schema.decodeUnknownSync(RendererConfigSchema);
@@ -27,11 +29,12 @@ export const defaultRendererConfig: RendererConfigShape = {
   renderIntervalMillis: 100, // 10 FPS
   maxLogLines: 0,
   nonTtyUpdateStep: 5,
+  determinateTaskLayout: "single-line",
 };
 
 export const defaultProgressBarConfig: ProgressBarConfigShape = {
-  spinnerFrames: ["-", "\\", "|", "/"],
-  barWidth: 30,
+  spinnerFrames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+  barWidth: 40,
   fillChar: "━",
   emptyChar: "─",
   leftBracket: "",
@@ -112,7 +115,7 @@ export interface RenderRow {
 export interface TaskStore {
   readonly tasks: Map<TaskId, TaskSnapshot>;
   readonly renderOrder: ReadonlyArray<RenderRow>;
-  readonly colorizers: Map<TaskId, ColorizerService>;
+  readonly themes: Map<TaskId, ThemeService>;
 }
 
 export interface ProgressService {

package/src/colors.ts

@@ -1,30 +0,0 @@
-import chalk from "chalk";
-import { Context, Layer } from "effect";
-
-export interface ColorizerService {
-  readonly fill: (text: string) => string;
-  readonly empty: (text: string) => string;
-  readonly brackets: (text: string) => string;
-  readonly percent: (text: string) => string;
-  readonly spinner: (text: string) => string;
-  readonly done: (text: string) => string;
-  readonly failed: (text: string) => string;
-}
-
-export class Colorizer extends Context.Tag("stromseng.dev/effective-progress/Colorizer")<
-  Colorizer,
-  ColorizerService
->() {
-  static readonly Default = Layer.succeed(
-    Colorizer,
-    Colorizer.of({
-      fill: chalk.blue,
-      empty: chalk.white.dim,
-      brackets: chalk.white.dim,
-      percent: chalk.white.bold,
-      spinner: chalk.yellow,
-      done: chalk.green,
-      failed: chalk.red,
-    }),
-  );
-}