effective-progress 0.2.4 → 0.4.0

package/src/runtime.ts

@@ -4,8 +4,9 @@ import { mergeWith } from "es-toolkit/object";
 import { formatWithOptions } from "node:util";
 import type { PartialDeep } from "type-fest";
 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,
@@ -87,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,
@@ -119,7 +133,6 @@ const removeFromRenderOrder = (
 const makeProgressService = Effect.gen(function* () {
   const rendererConfigOption = yield* Effect.serviceOption(RendererConfig);
   const progressBarConfigOption = yield* Effect.serviceOption(ProgressBarConfig);
-
   const rendererConfig = decodeRendererConfigSync(
     mergeConfig(
       defaultRendererConfig,
@@ -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,6 +154,7 @@ const makeProgressService = Effect.gen(function* () {
   const storeRef = yield* Ref.make<TaskStore>({
     tasks: new Map<TaskId, TaskSnapshot>(),
     renderOrder: [],
+    themes: new Map<TaskId, ThemeService>(),
   });
   const logsRef = yield* Ref.make<ReadonlyArray<string>>([]);
   const pendingLogsRef = yield* Ref.make<ReadonlyArray<string>>([]);
@@ -148,7 +163,7 @@ const makeProgressService = Effect.gen(function* () {
   const scope = yield* Effect.scope;
 
   yield* Effect.forkIn(
-    runProgressServiceRenderer(
+    frameRenderer.run({
       storeRef,
       logsRef,
       pendingLogsRef,
@@ -157,7 +172,7 @@ const makeProgressService = Effect.gen(function* () {
       isTTY,
       rendererConfig,
       maxRetainedLogLines,
-    ),
+    }),
     scope,
   );
 
@@ -169,6 +184,7 @@ const makeProgressService = Effect.gen(function* () {
         options.parentId === undefined
           ? yield* FiberRef.get(currentParentRef)
           : Option.some(options.parentId);
+      const themeOption = yield* Effect.serviceOption(Theme);
       const taskId = TaskId(yield* Ref.updateAndGet(nextTaskIdRef, (id) => id + 1));
       const units =
         options.total === undefined || options.total <= 0
@@ -190,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,
@@ -203,7 +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 });
-        return { tasks: nextTasks, renderOrder: nextOrder };
+        const nextThemes = new Map(s.themes);
+        if (Option.isSome(themeOption)) {
+          nextThemes.set(taskId, themeOption.value);
+        }
+        return { tasks: nextTasks, renderOrder: nextOrder, themes: nextThemes };
       });
       yield* markDirty;
 
@@ -215,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 };
+      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) =>
@@ -250,7 +294,7 @@ const makeProgressService = Effect.gen(function* () {
         }),
       );
 
-      return { tasks: nextTasks, renderOrder: store.renderOrder };
+      return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
     }).pipe(Effect.zipRight(markDirty));
 
   const completeTask = (taskId: TaskId) =>
@@ -263,7 +307,13 @@ const makeProgressService = Effect.gen(function* () {
         const nextTasks = new Map(store.tasks);
         if (snapshot.transient) {
           nextTasks.delete(taskId);
-          return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
+          const nextThemes = new Map(store.themes);
+          nextThemes.delete(taskId);
+          return {
+            tasks: nextTasks,
+            renderOrder: removeFromRenderOrder(store.renderOrder, taskId),
+            themes: nextThemes,
+          };
         }
 
         nextTasks.set(
@@ -286,7 +336,7 @@ const makeProgressService = Effect.gen(function* () {
             completedAt: now,
           }),
         );
-        return { tasks: nextTasks, renderOrder: store.renderOrder };
+        return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
       });
       yield* markDirty;
     });
@@ -301,7 +351,13 @@ const makeProgressService = Effect.gen(function* () {
         const nextTasks = new Map(store.tasks);
         if (snapshot.transient) {
           nextTasks.delete(taskId);
-          return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
+          const nextThemes = new Map(store.themes);
+          nextThemes.delete(taskId);
+          return {
+            tasks: nextTasks,
+            renderOrder: removeFromRenderOrder(store.renderOrder, taskId),
+            themes: nextThemes,
+          };
         }
 
         nextTasks.set(
@@ -318,7 +374,7 @@ const makeProgressService = Effect.gen(function* () {
             completedAt: now,
           }),
         );
-        return { tasks: nextTasks, renderOrder: store.renderOrder };
+        return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
       });
       yield* markDirty;
     });
@@ -371,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(
@@ -424,22 +480,40 @@ const makeProgressService = Effect.gen(function* () {
   return Progress.of(service);
 });
 
-export class Progress extends Context.Tag("stromseng.dev/Progress")<Progress, ProgressService>() {
-  static readonly Default = Layer.scoped(Progress, makeProgressService);
-}
-
-export const provideProgressService = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-  Effect.gen(function* () {
-    const existing = yield* Effect.serviceOption(Progress);
-    if (Option.isSome(existing)) {
-      return yield* Effect.provideService(effect, Progress, existing.value);
-    }
-
-    const existingTerminal = yield* Effect.serviceOption(ProgressTerminal);
-    if (Option.isSome(existingTerminal)) {
-      return yield* Effect.scoped(effect.pipe(Effect.provide(Progress.Default)));
-    }
+export class Progress extends Context.Tag("stromseng.dev/effective-progress/Progress")<
+  Progress,
+  ProgressService
+>() {
+  static readonly Default = Layer.unwrapEffect(
+    Effect.gen(function* () {
+      const themeOption = yield* Effect.serviceOption(Theme);
+      const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
+      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));
+      }
 
-    const defaultLayers = Layer.provide(Progress.Default, ProgressTerminal.Default);
-    return yield* Effect.scoped(effect.pipe(Effect.provide(defaultLayers)));
-  });
+      return layer as Layer.Layer<Progress, never, never>;
+    }),
+  );
+}

package/src/terminal.ts

@@ -42,18 +42,20 @@ const withRawInputCapture: ProgressTerminalService["withRawInputCapture"] = (eff
     );
   });
 
+const defaultTerminalService: ProgressTerminalService = {
+  isTTY: Effect.sync(() => Boolean(process.stderr.isTTY)),
+  stderrRows: Effect.sync(() => process.stderr.rows),
+  stderrColumns: Effect.sync(() => process.stderr.columns),
+  writeStderr: (text) =>
+    Effect.sync(() => {
+      process.stderr.write(text);
+    }),
+  withRawInputCapture,
+};
+
 export class ProgressTerminal extends Context.Tag("stromseng.dev/ProgressTerminal")<
   ProgressTerminal,
   ProgressTerminalService
 >() {
-  static readonly Default = Layer.succeed(ProgressTerminal, {
-    isTTY: Effect.sync(() => Boolean(process.stderr.isTTY)),
-    stderrRows: Effect.sync(() => process.stderr.rows),
-    stderrColumns: Effect.sync(() => process.stderr.columns),
-    writeStderr: (text) =>
-      Effect.sync(() => {
-        process.stderr.write(text);
-      }),
-    withRawInputCapture,
-  } satisfies ProgressTerminalService);
+  static readonly Default = Layer.succeed(ProgressTerminal, defaultTerminalService);
 }

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 { defaultProgressBarColors, ProgressBarColorsSchema } 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);
@@ -18,7 +20,6 @@ export const ProgressBarConfigSchema = Schema.Struct({
   emptyChar: Schema.String,
   leftBracket: Schema.String,
   rightBracket: Schema.String,
-  colors: ProgressBarColorsSchema,
 });
 export type ProgressBarConfigShape = typeof ProgressBarConfigSchema.Type;
 export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarConfigSchema);
@@ -28,27 +29,26 @@ 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: "",
   rightBracket: "",
-  colors: defaultProgressBarColors,
 };
 
-export class RendererConfig extends Context.Tag("stromseng.dev/RendererConfig")<
+export class RendererConfig extends Context.Tag("stromseng.dev/effective-progress/RendererConfig")<
   RendererConfig,
   PartialDeep<RendererConfigShape>
 >() {}
 
-export class ProgressBarConfig extends Context.Tag("stromseng.dev/ProgressBarConfig")<
-  ProgressBarConfig,
-  PartialDeep<ProgressBarConfigShape>
->() {}
+export class ProgressBarConfig extends Context.Tag(
+  "stromseng.dev/effective-progress/ProgressBarConfig",
+)<ProgressBarConfig, PartialDeep<ProgressBarConfigShape>>() {}
 
 const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
 
@@ -115,6 +115,7 @@ export interface RenderRow {
 export interface TaskStore {
   readonly tasks: Map<TaskId, TaskSnapshot>;
   readonly renderOrder: ReadonlyArray<RenderRow>;
+  readonly themes: Map<TaskId, ThemeService>;
 }
 
 export interface ProgressService {
@@ -146,7 +147,7 @@ export interface ProgressService {
   };
 }
 
-export class Task extends Context.Tag("stromseng.dev/Task")<Task, TaskId>() {}
+export class Task extends Context.Tag("stromseng.dev/effective-progress/Task")<Task, TaskId>() {}
 
 export class TaskAddedEvent extends Schema.TaggedClass<TaskAddedEvent>()("TaskAdded", {
   taskId: TaskIdSchema,

package/src/colors.ts

@@ -1,156 +0,0 @@
-import chalk from "chalk";
-import type { ChalkInstance } from "chalk";
-import { Schema } from "effect";
-
-export const StyleModifierSchema = Schema.Literal(
-  "bold",
-  "dim",
-  "italic",
-  "underline",
-  "inverse",
-  "hidden",
-  "strikethrough",
-);
-export type StyleModifier = typeof StyleModifierSchema.Type;
-
-export const NamedColorSchema = Schema.Literal(
-  "black",
-  "red",
-  "green",
-  "yellow",
-  "blue",
-  "magenta",
-  "cyan",
-  "white",
-  "blackBright",
-  "redBright",
-  "greenBright",
-  "yellowBright",
-  "blueBright",
-  "magentaBright",
-  "cyanBright",
-  "whiteBright",
-);
-export type NamedColor = typeof NamedColorSchema.Type;
-
-const HexColorSchema = Schema.String.pipe(Schema.pattern(/^#(?:[A-Fa-f0-9]{3}|[A-Fa-f0-9]{6})$/));
-const ColorChannelSchema = Schema.Number.pipe(
-  Schema.int(),
-  Schema.greaterThanOrEqualTo(0),
-  Schema.lessThanOrEqualTo(255),
-);
-const Ansi256Schema = Schema.Number.pipe(
-  Schema.int(),
-  Schema.greaterThanOrEqualTo(0),
-  Schema.lessThanOrEqualTo(255),
-);
-const ModifiersSchema = Schema.optional(Schema.Array(StyleModifierSchema));
-
-export const NamedColorStyleSchema = Schema.Struct({
-  kind: Schema.Literal("named"),
-  value: NamedColorSchema,
-  modifiers: ModifiersSchema,
-});
-
-export const HexColorStyleSchema = Schema.Struct({
-  kind: Schema.Literal("hex"),
-  value: HexColorSchema,
-  modifiers: ModifiersSchema,
-});
-
-export const RgbColorStyleSchema = Schema.Struct({
-  kind: Schema.Literal("rgb"),
-  value: Schema.Struct({
-    r: ColorChannelSchema,
-    g: ColorChannelSchema,
-    b: ColorChannelSchema,
-  }),
-  modifiers: ModifiersSchema,
-});
-
-export const Ansi256ColorStyleSchema = Schema.Struct({
-  kind: Schema.Literal("ansi256"),
-  value: Ansi256Schema,
-  modifiers: ModifiersSchema,
-});
-
-export const ColorStyleSchema = Schema.Union(
-  NamedColorStyleSchema,
-  HexColorStyleSchema,
-  RgbColorStyleSchema,
-  Ansi256ColorStyleSchema,
-);
-export type ColorStyle = typeof ColorStyleSchema.Type;
-
-export const ProgressBarColorsSchema = Schema.Struct({
-  fill: ColorStyleSchema,
-  empty: ColorStyleSchema,
-  brackets: ColorStyleSchema,
-  percent: ColorStyleSchema,
-  spinner: ColorStyleSchema,
-  done: ColorStyleSchema,
-  failed: ColorStyleSchema,
-});
-export type ProgressBarColors = typeof ProgressBarColorsSchema.Type;
-
-export const defaultProgressBarColors: ProgressBarColors = {
-  fill: { kind: "named", value: "cyan" },
-  empty: { kind: "named", value: "white", modifiers: ["dim"] },
-  brackets: { kind: "named", value: "white", modifiers: ["dim"] },
-  percent: { kind: "named", value: "white", modifiers: ["bold"] },
-  spinner: { kind: "named", value: "yellow" },
-  done: { kind: "named", value: "green" },
-  failed: { kind: "named", value: "red" },
-};
-
-const applyModifier = (instance: ChalkInstance, modifier: StyleModifier): ChalkInstance =>
-  instance[modifier];
-
-const applyNamedColor = (instance: ChalkInstance, color: NamedColor): ChalkInstance =>
-  instance[color];
-
-const resolveBaseStyle = (style: ColorStyle): ChalkInstance => {
-  switch (style.kind) {
-    case "named":
-      return applyNamedColor(chalk, style.value);
-    case "hex":
-      return chalk.hex(style.value);
-    case "rgb":
-      return chalk.rgb(style.value.r, style.value.g, style.value.b);
-    case "ansi256":
-      return chalk.ansi256(style.value);
-  }
-};
-
-const applyModifiers = (instance: ChalkInstance, modifiers: ReadonlyArray<StyleModifier>) => {
-  let styled = instance;
-  for (const modifier of modifiers) {
-    styled = applyModifier(styled, modifier);
-  }
-  return styled;
-};
-
-export const applyColorStyle = (style: ColorStyle, text: string): string => {
-  const styled = applyModifiers(resolveBaseStyle(style), style.modifiers ?? []);
-  return styled(text);
-};
-
-export interface CompiledProgressBarColors {
-  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 const compileProgressBarColors = (colors: ProgressBarColors): CompiledProgressBarColors => ({
-  fill: (text) => applyColorStyle(colors.fill, text),
-  empty: (text) => applyColorStyle(colors.empty, text),
-  brackets: (text) => applyColorStyle(colors.brackets, text),
-  percent: (text) => applyColorStyle(colors.percent, text),
-  spinner: (text) => applyColorStyle(colors.spinner, text),
-  done: (text) => applyColorStyle(colors.done, text),
-  failed: (text) => applyColorStyle(colors.failed, text),
-});