effective-progress 0.5.0 → 0.5.2

package/src/ink-renderer/service.tsx

@@ -1,121 +0,0 @@
-import { Writable } from "node:stream";
-import { Clock, Context, Effect, Layer, Ref } from "effect";
-import { render, type Instance } from "ink";
-import type { ProgressTerminalService } from "../terminal";
-import type { TaskSnapshot, TaskStore } from "../types";
-import { ProgressApp } from "./app";
-import { toTaskRows } from "./model";
-
-const RENDER_INTERVAL_MILLIS = 100;
-
-export interface InkRendererService {
-  readonly run: (
-    storeRef: Ref.Ref<TaskStore>,
-    dirtyRef: Ref.Ref<boolean>,
-    terminal: ProgressTerminalService,
-    isTTY: boolean,
-  ) => Effect.Effect<void>;
-}
-
-const hasRunningSpinners = (tasks: ReadonlyArray<TaskSnapshot>): boolean =>
-  tasks.some(
-    (task) => task.status === "running" && task.units._tag === "IndeterminateTaskUnits",
-  );
-
-const createInkWritable = (terminal: ProgressTerminalService): Writable =>
-  new Writable({
-    write(chunk, _encoding, callback) {
-      try {
-        const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : `${chunk}`;
-        Effect.runSync(terminal.writeStderr(text));
-        callback();
-      } catch (error) {
-        callback(error as Error);
-      }
-    },
-  });
-
-const makeDefaultInkRenderer = (): InkRendererService => ({
-  run: (storeRef, dirtyRef, terminal, isTTY) =>
-    Effect.gen(function* () {
-      const output = createInkWritable(terminal);
-      let instance: Instance | undefined;
-      let tick = 0;
-      let rendererActive = false;
-
-      const renderStore = (
-        store: TaskStore,
-        now: number,
-        terminalColumns: number | undefined,
-      ) =>
-        Effect.sync(() => {
-          const app = (
-            <ProgressApp
-              rows={toTaskRows(store)}
-              now={now}
-              tick={tick}
-              isTTY={isTTY}
-              terminalColumns={terminalColumns}
-            />
-          );
-          if (instance === undefined) {
-            instance = render(app, {
-              stdout: output as unknown as NodeJS.WriteStream,
-              stderr: output as unknown as NodeJS.WriteStream,
-              patchConsole: true,
-              exitOnCtrlC: false,
-              debug: false,
-            });
-            return;
-          }
-
-          instance.rerender(app);
-        });
-
-      const renderLoop = Effect.gen(function* () {
-        rendererActive = true;
-
-        while (true) {
-          const dirty = yield* Ref.getAndSet(dirtyRef, false);
-          const store = yield* Ref.get(storeRef);
-          const tasks = Array.from(store.tasks.values()).filter(
-            (task) => !(task.transient && task.status !== "running"),
-          );
-          const shouldRender = dirty || hasRunningSpinners(tasks);
-
-          if (shouldRender) {
-            const now = yield* Clock.currentTimeMillis;
-            const terminalColumns = isTTY ? yield* terminal.stderrColumns : undefined;
-            yield* renderStore(store, now, terminalColumns);
-          }
-
-          tick += 1;
-          yield* Effect.sleep(RENDER_INTERVAL_MILLIS);
-        }
-      }).pipe(
-        Effect.ensuring(
-          Effect.gen(function* () {
-            if (rendererActive) {
-              const store = yield* Ref.get(storeRef);
-              const now = yield* Clock.currentTimeMillis;
-              const terminalColumns = isTTY ? yield* terminal.stderrColumns : undefined;
-              yield* renderStore(store, now, terminalColumns);
-            }
-
-            yield* Effect.sync(() => {
-              instance?.unmount();
-            });
-          }),
-        ),
-      );
-
-      return yield* renderLoop;
-    }),
-});
-
-export class InkRenderer extends Context.Tag("stromseng.dev/effective-progress/InkRenderer")<
-  InkRenderer,
-  InkRendererService
->() {
-  static readonly Default = Layer.succeed(InkRenderer, InkRenderer.of(makeDefaultInkRenderer()));
-}

package/src/ink-renderer/task-row.tsx

@@ -1,53 +0,0 @@
-import { Box } from "ink";
-import { DEFAULT_BAR_WIDTH, type SharedColumnWidths } from "./layout";
-import type { TaskRowModel } from "./types";
-import {
-  AmountColumn,
-  BarColumn,
-  DescriptionColumn,
-  ElapsedColumn,
-  EtaColumn,
-} from "./columns";
-
-export interface TaskRowProps {
-  readonly row: TaskRowModel;
-  readonly now: number;
-  readonly tick: number;
-  readonly isTTY: boolean;
-  readonly widths: SharedColumnWidths;
-}
-
-export const TaskRow = ({ row, now, tick, isTTY, widths }: TaskRowProps) => {
-  const props = {
-    task: row.task,
-    tree: row.tree,
-    now,
-    tick,
-    isTTY,
-    showTree: widths.showTree,
-  } as const;
-
-  return (
-    <Box flexDirection="row" minWidth={widths.row}>
-      <Box width={widths.description} flexShrink={1} marginRight={1}>
-        <DescriptionColumn {...props} />
-      </Box>
-      {widths.bar > 0 ? (
-        <Box width={widths.bar} flexShrink={0} marginRight={1}>
-          <BarColumn {...props} width={Math.max(1, Math.min(widths.bar, DEFAULT_BAR_WIDTH))} />
-        </Box>
-      ) : null}
-      <Box width={widths.amount} flexShrink={0} marginRight={1}>
-        <AmountColumn {...props} />
-      </Box>
-      <Box width={widths.elapsed} flexShrink={0} marginRight={1}>
-        <ElapsedColumn {...props} />
-      </Box>
-      {widths.eta > 0 ? (
-        <Box width={widths.eta} flexShrink={0}>
-          <EtaColumn {...props} />
-        </Box>
-      ) : null}
-    </Box>
-  );
-};

package/src/ink-renderer/tree.ts

@@ -1,62 +0,0 @@
-import type { OrderedTask, TaskTreeInfo } from "./types";
-
-const treeAncestorPrefix = (tree: TaskTreeInfo): string =>
-  tree.ancestorHasNextSibling
-    .slice(1)
-    .map((hasNext) => (hasNext ? "│  " : "   "))
-    .join("");
-
-export const renderTreePrefix = (tree: TaskTreeInfo): string => {
-  if (tree.depth <= 0) {
-    return "";
-  }
-
-  const ancestor = treeAncestorPrefix(tree);
-  return `${ancestor}${tree.hasNextSibling ? "├─ " : "└─ "}`;
-};
-
-export const computeTreeInfo = (
-  ordered: ReadonlyArray<OrderedTask>,
-): ReadonlyArray<OrderedTask & { readonly tree: TaskTreeInfo }> => {
-  const hasNextSiblingByIndex: Array<boolean> = Array.from({ length: ordered.length }, () => false);
-
-  for (let i = 0; i < ordered.length; i++) {
-    const depth = ordered[i]!.depth;
-    for (let j = i + 1; j < ordered.length; j++) {
-      const candidateDepth = ordered[j]!.depth;
-      if (candidateDepth < depth) {
-        break;
-      }
-      if (candidateDepth === depth) {
-        hasNextSiblingByIndex[i] = true;
-        break;
-      }
-    }
-  }
-
-  const ancestorStateByDepth: Array<boolean> = [];
-
-  return ordered.map((entry, index) => {
-    const depth = entry.depth;
-    ancestorStateByDepth.length = depth;
-
-    const hasChildren =
-      index + 1 < ordered.length &&
-      ordered[index + 1] !== undefined &&
-      ordered[index + 1]!.depth > depth;
-
-    const tree: TaskTreeInfo = {
-      depth,
-      hasNextSibling: hasNextSiblingByIndex[index] ?? false,
-      hasChildren,
-      ancestorHasNextSibling: [...ancestorStateByDepth],
-    };
-
-    ancestorStateByDepth[depth] = hasNextSiblingByIndex[index] ?? false;
-
-    return {
-      ...entry,
-      tree,
-    };
-  });
-};

package/src/ink-renderer/types.ts

@@ -1,18 +0,0 @@
-import type { TaskSnapshot } from "../types";
-
-export interface TaskTreeInfo {
-  readonly depth: number;
-  readonly hasNextSibling: boolean;
-  readonly hasChildren: boolean;
-  readonly ancestorHasNextSibling: ReadonlyArray<boolean>;
-}
-
-export interface OrderedTask {
-  readonly snapshot: TaskSnapshot;
-  readonly depth: number;
-}
-
-export interface TaskRowModel {
-  readonly task: TaskSnapshot;
-  readonly tree: TaskTreeInfo;
-}

package/src/runtime.ts

@@ -1,396 +0,0 @@
-import { Clock, Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
-import { dual } from "effect/Function";
-import { InkRenderer } from "./ink-renderer";
-import { ProgressTerminal } from "./terminal";
-import type {
-  AddTaskOptions,
-  ProgressService,
-  RenderRow,
-  TaskStore,
-  UpdateTaskOptions,
-} from "./types";
-import {
-  DeterminateTaskUnits,
-  IndeterminateTaskUnits,
-  Task,
-  TaskId,
-  TaskSnapshot,
-} from "./types";
-
-const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): TaskSnapshot => {
-  const currentUnits = snapshot.units;
-  const units = (() => {
-    if (options.total !== undefined) {
-      if (options.total <= 0) {
-        return new IndeterminateTaskUnits({ spinnerFrame: 0 });
-      }
-
-      const completed =
-        options.completed ??
-        (currentUnits._tag === "DeterminateTaskUnits" ? currentUnits.completed : 0);
-
-      return new DeterminateTaskUnits({
-        completed: Math.max(0, completed),
-        total: Math.max(0, options.total),
-      });
-    }
-
-    if (currentUnits._tag === "DeterminateTaskUnits") {
-      if (options.completed === undefined) {
-        return currentUnits;
-      }
-
-      return new DeterminateTaskUnits({
-        completed: Math.max(0, options.completed),
-        total: currentUnits.total,
-      });
-    }
-
-    return currentUnits;
-  })();
-
-  return new TaskSnapshot({
-    id: snapshot.id,
-    parentId: snapshot.parentId,
-    description: options.description ?? snapshot.description,
-    status: snapshot.status,
-    transient: options.transient ?? snapshot.transient,
-    units,
-    startedAt: snapshot.startedAt,
-    completedAt: snapshot.completedAt,
-  });
-};
-
-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,
-    startedAt: snapshot.startedAt,
-    completedAt: snapshot.completedAt,
-  });
-
-const findInsertionIndex = (
-  renderOrder: ReadonlyArray<RenderRow>,
-  parentId: TaskId | null,
-): { index: number; depth: number } => {
-  if (parentId === null) {
-    return { index: renderOrder.length, depth: 0 };
-  }
-  const parentIdx = renderOrder.findIndex((row) => row.id === parentId);
-  if (parentIdx === -1) return { index: renderOrder.length, depth: 0 };
-  const parentDepth = renderOrder[parentIdx]!.depth;
-  let i = parentIdx + 1;
-  while (i < renderOrder.length && renderOrder[i]!.depth > parentDepth) i++;
-  return { index: i, depth: parentDepth + 1 };
-};
-
-const removeFromRenderOrder = (
-  renderOrder: ReadonlyArray<RenderRow>,
-  taskId: TaskId,
-): ReadonlyArray<RenderRow> => {
-  const idx = renderOrder.findIndex((row) => row.id === taskId);
-  if (idx === -1) return renderOrder;
-  const taskDepth = renderOrder[idx]!.depth;
-  let end = idx + 1;
-  while (end < renderOrder.length && renderOrder[end]!.depth > taskDepth) end++;
-  const next = [...renderOrder];
-  next.splice(idx, end - idx);
-  return next;
-};
-
-const makeProgressService = Effect.gen(function* () {
-  const terminal = yield* ProgressTerminal;
-  const inkRenderer = yield* InkRenderer;
-  const outerConsole = yield* Effect.console;
-  const isTTY = yield* terminal.isTTY;
-
-  const nextTaskIdRef = yield* Ref.make(0);
-  const storeRef = yield* Ref.make<TaskStore>({
-    tasks: new Map<TaskId, TaskSnapshot>(),
-    renderOrder: [],
-  });
-  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 log = (...args: ReadonlyArray<unknown>) =>
-    args.length === 0 ? Effect.void : outerConsole.log(...args);
-
-  yield* Effect.forkIn(inkRenderer.run(storeRef, dirtyRef, terminal, isTTY), scope);
-  // 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* () {
-      const resolvedParentId =
-        options.parentId === undefined
-          ? yield* FiberRef.get(currentParentRef)
-          : Option.some(options.parentId);
-      const taskId = TaskId(yield* Ref.updateAndGet(nextTaskIdRef, (id) => id + 1));
-      const units =
-        options.total === undefined || options.total <= 0
-          ? new IndeterminateTaskUnits({ spinnerFrame: 0 })
-          : new DeterminateTaskUnits({ completed: 0, total: Math.max(0, options.total) });
-      const store = yield* Ref.get(storeRef);
-      const parentSnapshot = Option.isSome(resolvedParentId)
-        ? store.tasks.get(resolvedParentId.value)
-        : undefined;
-
-      const now = yield* Clock.currentTimeMillis;
-      const parentIdValue = Option.getOrNull(resolvedParentId);
-      const snapshot = new TaskSnapshot({
-        id: taskId,
-        parentId: parentIdValue,
-        description: options.description,
-        status: "running",
-        transient: parentSnapshot?.transient ?? options.transient ?? false,
-        units,
-        startedAt: now,
-        completedAt: null,
-      });
-
-      yield* Ref.update(storeRef, (s) => {
-        const nextTasks = new Map(s.tasks);
-        nextTasks.set(taskId, snapshot);
-        const { index, depth } = findInsertionIndex(s.renderOrder, parentIdValue);
-        const nextOrder = [...s.renderOrder];
-        nextOrder.splice(index, 0, { id: taskId, depth });
-        return { tasks: nextTasks, renderOrder: nextOrder };
-      });
-      yield* markDirty;
-
-      return taskId;
-    });
-
-  const updateTask = (taskId: TaskId, options: UpdateTaskOptions) =>
-    Ref.update(storeRef, (store) => {
-      const snapshot = store.tasks.get(taskId);
-      if (!snapshot) return store;
-      const nextTasks = new Map(store.tasks);
-      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 };
-    }).pipe(Effect.zipRight(markDirty));
-
-  const advanceTask = (taskId: TaskId, amount = 1) =>
-    Ref.update(storeRef, (store) => {
-      const snapshot = store.tasks.get(taskId);
-      if (!snapshot) return store;
-
-      const units =
-        snapshot.units._tag === "DeterminateTaskUnits"
-          ? new DeterminateTaskUnits({
-              completed: Math.min(snapshot.units.total, snapshot.units.completed + amount),
-              total: snapshot.units.total,
-            })
-          : new IndeterminateTaskUnits({
-              spinnerFrame: Math.max(0, snapshot.units.spinnerFrame + amount),
-            });
-
-      const nextTasks = new Map(store.tasks);
-      nextTasks.set(
-        taskId,
-        new TaskSnapshot({
-          id: snapshot.id,
-          parentId: snapshot.parentId,
-          description: snapshot.description,
-          status: snapshot.status,
-          transient: snapshot.transient,
-          units,
-          startedAt: snapshot.startedAt,
-          completedAt: snapshot.completedAt,
-        }),
-      );
-
-      return { tasks: nextTasks, renderOrder: store.renderOrder };
-    }).pipe(Effect.zipRight(markDirty));
-
-  const completeTask = (taskId: TaskId) =>
-    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,
-            startedAt: snapshot.startedAt,
-            completedAt: now,
-          }),
-        );
-        return { tasks: nextTasks, renderOrder: store.renderOrder };
-      });
-      yield* markDirty;
-    });
-
-  const failTask = (taskId: TaskId) =>
-    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,
-            startedAt: snapshot.startedAt,
-            completedAt: now,
-          }),
-        );
-        return { tasks: nextTasks, renderOrder: store.renderOrder };
-      });
-      yield* markDirty;
-    });
-
-  const getTask = (taskId: TaskId) =>
-    Ref.get(storeRef).pipe(Effect.map((store) => Option.fromNullable(store.tasks.get(taskId))));
-
-  const listTasks = Ref.get(storeRef).pipe(Effect.map((store) => Array.from(store.tasks.values())));
-
-  const runTask: ProgressService["runTask"] = dual(
-    2,
-    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
-      Effect.gen(function* () {
-        const inheritedParentId = yield* FiberRef.get(currentParentRef);
-        const resolvedParentId =
-          options.parentId === undefined ? inheritedParentId : Option.some(options.parentId);
-
-        const taskId = yield* addTask({
-          ...options,
-          parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : undefined,
-          transient: options.transient,
-        });
-
-        return yield* Effect.locally(
-          Effect.provideService(effect, Task, taskId),
-          currentParentRef,
-          Option.some(taskId),
-        );
-      }),
-  );
-
-  const withTask: ProgressService["withTask"] = dual(
-    2,
-    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
-      runTask(
-        Effect.gen(function* () {
-          const taskId = yield* Task;
-          const exit = yield* Effect.exit(effect);
-
-          if (Exit.isSuccess(exit)) {
-            yield* completeTask(taskId);
-          } else {
-            yield* failTask(taskId);
-          }
-
-          return yield* Exit.match(exit, {
-            onFailure: Effect.failCause,
-            onSuccess: Effect.succeed,
-          });
-        }),
-        options,
-      ),
-  );
-
-  const service: ProgressService = {
-    addTask,
-    updateTask,
-    advanceTask,
-    completeTask,
-    failTask,
-    log,
-    getTask,
-    listTasks,
-    runTask,
-    withTask,
-  };
-
-  return Progress.of(service);
-});
-
-export class Progress extends Context.Tag("stromseng.dev/effective-progress/Progress")<
-  Progress,
-  ProgressService
->() {
-  static readonly Default = Layer.unwrapEffect(
-    Effect.gen(function* () {
-      const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
-      const inkRendererOption = yield* Effect.serviceOption(InkRenderer);
-      let layer: Layer.Layer<Progress, never, any> = Layer.scoped(Progress, makeProgressService);
-
-      if (Option.isNone(inkRendererOption)) {
-        layer = layer.pipe(Layer.provide(InkRenderer.Default));
-      }
-      if (Option.isNone(terminalOption)) {
-        layer = layer.pipe(Layer.provide(ProgressTerminal.Default));
-      }
-
-      return layer as Layer.Layer<Progress, never, never>;
-    }),
-  );
-}