effective-progress 0.4.1 → 0.4.3

package/src/runtime.ts

@@ -1,16 +1,15 @@
 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";
 import type { PartialDeep } from "type-fest";
-import { makeProgressConsole } from "./console";
-import { BuildStage, ColorStage, FrameRenderer, ShrinkStage } from "./renderer";
+import { type BufferedConsoleCall, makeConsoleBridge } from "./console";
+import { Columns, FrameRenderer } from "./renderer";
 import { ProgressTerminal } from "./terminal";
-import { Theme, type ThemeService } from "./theme";
 import type {
   AddTaskOptions,
   ProgressService,
   RenderRow,
+  RendererConfigShape,
   TaskStore,
   UpdateTaskOptions,
 } from "./types";
@@ -130,53 +129,67 @@ const removeFromRenderOrder = (
   return next;
 };
 
+const withDefaultColumns = (rendererConfig: RendererConfigShape): RendererConfigShape => ({
+  ...rendererConfig,
+  columns: rendererConfig.columns.length > 0 ? rendererConfig.columns : Columns.defaults(),
+});
+
 const makeProgressService = Effect.gen(function* () {
   const rendererConfigOption = yield* Effect.serviceOption(RendererConfig);
   const progressBarConfigOption = yield* Effect.serviceOption(ProgressBarConfig);
-  const rendererConfig = decodeRendererConfigSync(
-    mergeConfig(
-      defaultRendererConfig,
-      Option.isSome(rendererConfigOption) ? rendererConfigOption.value : undefined,
+
+  const rendererConfig = withDefaultColumns(
+    decodeRendererConfigSync(
+      mergeConfig(
+        defaultRendererConfig,
+        Option.isSome(rendererConfigOption) ? rendererConfigOption.value : undefined,
+      ),
     ),
   );
+
   const progressBarConfig = decodeProgressBarConfigSync(
     mergeConfig(
       defaultProgressBarConfig,
       Option.isSome(progressBarConfigOption) ? progressBarConfigOption.value : undefined,
     ),
   );
+
   const terminal = yield* ProgressTerminal;
   const frameRenderer = yield* FrameRenderer;
+  const outerConsole = yield* Effect.console;
   const isTTY = yield* terminal.isTTY;
-  const maxRetainedLogLines = Math.max(0, Math.floor(rendererConfig.maxLogLines ?? 0));
 
   const nextTaskIdRef = yield* Ref.make(0);
   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>>([]);
+  const pendingLogsRef = yield* Ref.make<ReadonlyArray<BufferedConsoleCall>>([]);
   const dirtyRef = yield* Ref.make(true);
   const currentParentRef = yield* FiberRef.make(Option.none<TaskId>());
   const scope = yield* Effect.scope;
 
+  const markDirty = Ref.set(dirtyRef, true);
+  const { replayLogs, progressConsole, log } = makeConsoleBridge(
+    outerConsole,
+    pendingLogsRef,
+    markDirty,
+  );
+
   yield* Effect.forkIn(
-    frameRenderer.run({
+    frameRenderer.run(
       storeRef,
-      logsRef,
       pendingLogsRef,
+      replayLogs,
       dirtyRef,
       terminal,
       isTTY,
       rendererConfig,
-      maxRetainedLogLines,
-    }),
+    ),
     scope,
   );
-
-  const markDirty = Ref.set(dirtyRef, true);
+  // Let the renderer fiber start so queued logs are reliably flushed on scope teardown.
+  yield* Effect.sleep("0 millis");
 
   const addTask = (options: AddTaskOptions) =>
     Effect.gen(function* () {
@@ -184,7 +197,6 @@ 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
@@ -219,11 +231,7 @@ const makeProgressService = Effect.gen(function* () {
         const { index, depth } = findInsertionIndex(s.renderOrder, parentIdValue);
         const nextOrder = [...s.renderOrder];
         nextOrder.splice(index, 0, { id: taskId, depth });
-        const nextThemes = new Map(s.themes);
-        if (Option.isSome(themeOption)) {
-          nextThemes.set(taskId, themeOption.value);
-        }
-        return { tasks: nextTasks, renderOrder: nextOrder, themes: nextThemes };
+        return { tasks: nextTasks, renderOrder: nextOrder };
       });
       yield* markDirty;
 
@@ -260,7 +268,7 @@ const makeProgressService = Effect.gen(function* () {
         }
       }
 
-      return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
+      return { tasks: nextTasks, renderOrder: store.renderOrder };
     }).pipe(Effect.zipRight(markDirty));
 
   const advanceTask = (taskId: TaskId, amount = 1) =>
@@ -294,7 +302,7 @@ const makeProgressService = Effect.gen(function* () {
         }),
       );
 
-      return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
+      return { tasks: nextTasks, renderOrder: store.renderOrder };
     }).pipe(Effect.zipRight(markDirty));
 
   const completeTask = (taskId: TaskId) =>
@@ -307,12 +315,9 @@ const makeProgressService = Effect.gen(function* () {
         const nextTasks = new Map(store.tasks);
         if (snapshot.transient) {
           nextTasks.delete(taskId);
-          const nextThemes = new Map(store.themes);
-          nextThemes.delete(taskId);
           return {
             tasks: nextTasks,
             renderOrder: removeFromRenderOrder(store.renderOrder, taskId),
-            themes: nextThemes,
           };
         }
 
@@ -336,7 +341,7 @@ const makeProgressService = Effect.gen(function* () {
             completedAt: now,
           }),
         );
-        return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
+        return { tasks: nextTasks, renderOrder: store.renderOrder };
       });
       yield* markDirty;
     });
@@ -351,12 +356,9 @@ const makeProgressService = Effect.gen(function* () {
         const nextTasks = new Map(store.tasks);
         if (snapshot.transient) {
           nextTasks.delete(taskId);
-          const nextThemes = new Map(store.themes);
-          nextThemes.delete(taskId);
           return {
             tasks: nextTasks,
             renderOrder: removeFromRenderOrder(store.renderOrder, taskId),
-            themes: nextThemes,
           };
         }
 
@@ -374,42 +376,11 @@ const makeProgressService = Effect.gen(function* () {
             completedAt: now,
           }),
         );
-        return { tasks: nextTasks, renderOrder: store.renderOrder, themes: store.themes };
+        return { tasks: nextTasks, renderOrder: store.renderOrder };
       });
       yield* markDirty;
     });
 
-  const appendLog = (args: ReadonlyArray<unknown>) =>
-    Effect.gen(function* () {
-      if (args.length === 0) {
-        return;
-      }
-
-      // TODO: Might wanna replace this or make it configurable. Look for other options.
-      const message = formatWithOptions(
-        {
-          colors: isTTY,
-          depth: 6,
-        },
-        ...args,
-      );
-
-      yield* Ref.update(pendingLogsRef, (logs) => [...logs, message]);
-      if (maxRetainedLogLines > 0) {
-        yield* Ref.update(logsRef, (logs) => {
-          const next = [...logs, message];
-          if (next.length <= maxRetainedLogLines) {
-            return next;
-          }
-          return next.slice(next.length - maxRetainedLogLines);
-        });
-      }
-
-      yield* markDirty;
-    });
-
-  const log = (...args: ReadonlyArray<unknown>) => appendLog(args);
-
   const getTask = (taskId: TaskId) =>
     Ref.get(storeRef).pipe(Effect.map((store) => Option.fromNullable(store.tasks.get(taskId))));
 
@@ -419,7 +390,6 @@ const makeProgressService = Effect.gen(function* () {
     2,
     <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
       Effect.gen(function* () {
-        const outerConsole = yield* Effect.console;
         const inheritedParentId = yield* FiberRef.get(currentParentRef);
         const resolvedParentId =
           options.parentId === undefined ? inheritedParentId : Option.some(options.parentId);
@@ -431,10 +401,7 @@ const makeProgressService = Effect.gen(function* () {
         });
 
         return yield* Effect.locally(
-          Effect.withConsole(
-            Effect.provideService(effect, Task, taskId),
-            makeProgressConsole(log, outerConsole),
-          ),
+          Effect.withConsole(Effect.provideService(effect, Task, taskId), progressConsole),
           currentParentRef,
           Option.some(taskId),
         );
@@ -486,29 +453,13 @@ export class Progress extends Context.Tag("stromseng.dev/effective-progress/Prog
 >() {
   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));
       }

package/src/types.ts

@@ -1,17 +1,34 @@
 import { Brand, Context, Effect, Option, Schema } from "effect";
 import type { PartialDeep } from "type-fest";
-import type { ThemeService } from "./theme";
+import type { ProgressColumn } from "./renderer";
 
 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),
+  width: Schema.Union(Schema.Number, Schema.Literal("fullwidth")),
+  columnGap: Schema.Number,
+  columns: Schema.Array(Schema.Unknown),
 });
-export type RendererConfigShape = typeof RendererConfigSchema.Type;
-export const decodeRendererConfigSync = Schema.decodeUnknownSync(RendererConfigSchema);
+export type RendererConfigShape = {
+  readonly disableUserInput: boolean;
+  readonly renderIntervalMillis: number;
+  readonly nonTtyUpdateStep: number;
+  readonly width: number | "fullwidth";
+  readonly columnGap: number;
+  readonly columns: ReadonlyArray<ProgressColumn | string>;
+};
+const decodeRendererConfigSchemaSync = Schema.decodeUnknownSync(RendererConfigSchema);
+export const decodeRendererConfigSync = (input: unknown): RendererConfigShape => {
+  if (typeof input === "object" && input !== null && "determinateTaskLayout" in input) {
+    throw new Error("determinateTaskLayout has been removed. Use columns instead.");
+  }
+  if (typeof input === "object" && input !== null && "maxTaskWidth" in input) {
+    throw new Error("maxTaskWidth has been removed. Use width on RendererConfig instead.");
+  }
+
+  return decodeRendererConfigSchemaSync(input) as RendererConfigShape;
+};
 
 export const ProgressBarConfigSchema = Schema.Struct({
   spinnerFrames: Schema.NonEmptyArray(Schema.String),
@@ -27,9 +44,10 @@ export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarC
 export const defaultRendererConfig: RendererConfigShape = {
   disableUserInput: true,
   renderIntervalMillis: 100, // 10 FPS
-  maxLogLines: 0,
   nonTtyUpdateStep: 5,
-  determinateTaskLayout: "single-line",
+  width: 120,
+  columnGap: 1,
+  columns: [],
 };
 
 export const defaultProgressBarConfig: ProgressBarConfigShape = {
@@ -115,7 +133,6 @@ export interface RenderRow {
 export interface TaskStore {
   readonly tasks: Map<TaskId, TaskSnapshot>;
   readonly renderOrder: ReadonlyArray<RenderRow>;
-  readonly themes: Map<TaskId, ThemeService>;
 }
 
 export interface ProgressService {

package/src/theme.ts

@@ -1,87 +0,0 @@
-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),
-          },
-        }),
-      );
-    }),
-  );
-}