effective-progress 0.5.1 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effective-progress",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {
@@ -12,13 +12,21 @@
     "url": "git+https://github.com/stromseng/effective-progress.git"
   },
   "files": [
-    "index.ts",
-    "src",
+    "dist",
     "README.md",
     "LICENSE"
   ],
   "type": "module",
-  "module": "index.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
   "engines": {
     "node": ">=20.12.0"
   },
@@ -27,6 +35,8 @@
   },
   "scripts": {
     "prepare": "effect-language-service patch",
+    "build": "tsdown",
+    "prepublishOnly": "bun run build",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint .",
     "format": "oxfmt --write .",
@@ -43,6 +53,7 @@
     "effect": "^3.19.17",
     "oxfmt": "^0.32.0",
     "oxlint": "^1.47.0",
+    "tsdown": "^0.21.0-beta.2",
     "typescript": "^5"
   },
   "peerDependencies": {

package/index.ts

@@ -1 +0,0 @@
-export * from "./src";

package/src/api.ts

@@ -1,197 +0,0 @@
-import { Effect, Exit, Option } from "effect";
-import { dual } from "effect/Function";
-import type { Concurrency } from "effect/Types";
-import { Progress } from "./runtime";
-import { Task } from "./types";
-import type { AddTaskOptions, TrackOptions } from "./types";
-import { inferTotal } from "./utils";
-
-const provideProgress = <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);
-    }
-    return yield* Effect.scoped(effect.pipe(Effect.provide(Progress.Default)));
-  });
-
-export interface EffectExecutionOptions {
-  readonly concurrency?: Concurrency;
-  readonly batching?: boolean | "inherit";
-  readonly concurrentFinalizers?: boolean;
-}
-
-export interface EffectAllExecutionOptions extends EffectExecutionOptions {
-  readonly discard?: boolean;
-  readonly mode?: "default" | "validate" | "either";
-}
-
-export type AllOptions = Omit<TrackOptions, "total"> & EffectAllExecutionOptions;
-export type AllReturn<
-  Arg extends
-    | ReadonlyArray<Effect.Effect<any, any, any>>
-    | Record<string, Effect.Effect<any, any, any>>,
-  O extends EffectAllExecutionOptions,
-> = [
-  [Arg] extends [ReadonlyArray<Effect.Effect<any, any, any>>]
-    ? Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>>
-    : [Arg] extends [Record<string, Effect.Effect<any, any, any>>]
-      ? Effect.All.ReturnObject<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>>
-      : never,
-] extends [Effect.Effect<infer A, infer E, infer R>]
-  ? Effect.Effect<A, E, Exclude<R, Progress | Task>>
-  : never;
-
-export interface ForEachExecutionOptions extends EffectExecutionOptions {
-  readonly discard?: false | undefined;
-}
-
-export type ForEachOptions = TrackOptions & ForEachExecutionOptions;
-
-export type TaskOptions = AddTaskOptions;
-
-export const task: {
-  <A, E, R>(
-    effect: Effect.Effect<A, E, R>,
-    options: TaskOptions,
-  ): Effect.Effect<A, E, Exclude<R, Progress | Task>>;
-  <A, E, R>(
-    options: TaskOptions,
-  ): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Progress | Task>>;
-} = dual(2, <A, E, R>(effect: Effect.Effect<A, E, R>, options: TaskOptions) => {
-  return provideProgress(
-    Effect.gen(function* () {
-      const progress = yield* Progress;
-      return yield* progress.withTask(effect, options);
-    }),
-  ) as Effect.Effect<A, E, Exclude<R, Progress | Task>>;
-});
-
-type AllArg =
-  | ReadonlyArray<Effect.Effect<any, any, any>>
-  | Record<string, Effect.Effect<any, any, any>>;
-
-const wrapEffects = (
-  effects: AllArg,
-  tap: (effect: Effect.Effect<any, any, any>) => Effect.Effect<any, any, any>,
-): AllArg =>
-  Array.isArray(effects)
-    ? effects.map(tap)
-    : Object.fromEntries(Object.entries(effects).map(([k, effect]) => [k, tap(effect)]));
-
-const countEffects = (effects: AllArg): number =>
-  Array.isArray(effects) ? effects.length : Object.keys(effects).length;
-
-export const all: {
-  <const Arg extends AllArg, O extends EffectAllExecutionOptions>(
-    effects: Arg,
-    options: Omit<TrackOptions, "total"> & O,
-  ): AllReturn<Arg, O>;
-  <O extends EffectAllExecutionOptions>(
-    options: Omit<TrackOptions, "total"> & O,
-  ): <const Arg extends AllArg>(effects: Arg) => AllReturn<Arg, O>;
-} = dual(
-  2,
-  <const Arg extends AllArg, O extends EffectAllExecutionOptions>(
-    effects: Arg,
-    options: Omit<TrackOptions, "total"> & O,
-  ) =>
-    provideProgress(
-      Effect.gen(function* () {
-        const progress = yield* Progress;
-        return yield* progress.runTask(
-          Effect.gen(function* () {
-            const taskId = yield* Task;
-            const exit = yield* Effect.exit(
-              Effect.all(
-                wrapEffects(effects, (effect) =>
-                  Effect.tap(effect, () => progress.advanceTask(taskId, 1)),
-                ),
-                {
-                  concurrency: options.concurrency,
-                  batching: options.batching,
-                  discard: options.discard,
-                  mode: options.mode,
-                  concurrentFinalizers: options.concurrentFinalizers,
-                },
-              ),
-            );
-
-            if (Exit.isSuccess(exit)) {
-              yield* progress.completeTask(taskId);
-            } else {
-              yield* progress.failTask(taskId);
-            }
-
-            return yield* Exit.match(exit, {
-              onFailure: Effect.failCause,
-              onSuccess: Effect.succeed,
-            });
-          }),
-          {
-            description: options.description,
-            total: countEffects(effects),
-            transient: options.transient,
-          },
-        );
-      }),
-    ) as AllReturn<Arg, O>,
-);
-
-export const forEach: {
-  <A, B, E, R>(
-    iterable: Iterable<A>,
-    f: (item: A, index: number) => Effect.Effect<B, E, R>,
-    options: ForEachOptions,
-  ): Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
-  <A, B, E, R>(
-    f: (item: A, index: number) => Effect.Effect<B, E, R>,
-    options: ForEachOptions,
-  ): (iterable: Iterable<A>) => Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
-} = dual(
-  3,
-  <A, B, E, R>(
-    iterable: Iterable<A>,
-    f: (item: A, index: number) => Effect.Effect<B, E, R>,
-    options: ForEachOptions,
-  ) =>
-    provideProgress(
-      Effect.gen(function* () {
-        const progress = yield* Progress;
-
-        return yield* progress.runTask(
-          Effect.gen(function* () {
-            const taskId = yield* Task;
-            const exit = yield* Effect.exit(
-              Effect.forEach(
-                iterable,
-                (item, index) => Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)),
-                {
-                  concurrency: options.concurrency,
-                  batching: options.batching,
-                  discard: options.discard,
-                  concurrentFinalizers: options.concurrentFinalizers,
-                },
-              ),
-            );
-
-            if (Exit.isSuccess(exit)) {
-              yield* progress.completeTask(taskId);
-            } else {
-              yield* progress.failTask(taskId);
-            }
-
-            return yield* Exit.match(exit, {
-              onFailure: Effect.failCause,
-              onSuccess: Effect.succeed,
-            });
-          }),
-          {
-            description: options.description,
-            total: options.total ?? inferTotal(iterable),
-            transient: options.transient,
-          },
-        );
-      }),
-    ) as Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>,
-);

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./api";
-export { Progress } from "./runtime";
-export * from "./terminal";
-export * from "./types";

package/src/ink-renderer/app.tsx

@@ -1,31 +0,0 @@
-import { Box } from "ink";
-import { computeSharedColumnWidths } from "./layout";
-import { TaskRow } from "./task-row";
-import type { TaskRowModel } from "./types";
-
-export interface ProgressAppProps {
-  readonly rows: ReadonlyArray<TaskRowModel>;
-  readonly now: number;
-  readonly tick: number;
-  readonly isTTY: boolean;
-  readonly terminalColumns?: number;
-}
-
-export const ProgressApp = ({ rows, now, tick, isTTY, terminalColumns }: ProgressAppProps) => {
-  const widths = computeSharedColumnWidths(rows, now, tick, terminalColumns);
-
-  return (
-    <Box flexDirection="column">
-      {rows.map((row) => (
-        <TaskRow
-          key={row.task.id as number}
-          row={row}
-          now={now}
-          tick={tick}
-          isTTY={isTTY}
-          widths={widths}
-        />
-      ))}
-    </Box>
-  );
-};

package/src/ink-renderer/columns/amount-column.tsx

@@ -1,17 +0,0 @@
-import { Text } from "ink";
-import { formatAmount } from "../format";
-import type { ColumnProps } from "./types";
-
-export const AmountColumn = ({ task, tick }: ColumnProps) => {
-  const text = formatAmount(task, tick);
-  const color =
-    task.status === "failed"
-      ? "red"
-      : task.status === "done"
-        ? "green"
-        : task.units._tag === "DeterminateTaskUnits"
-          ? "whiteBright"
-          : "yellow";
-
-  return <Text color={color}>{text}</Text>;
-};

package/src/ink-renderer/columns/bar-column.tsx

@@ -1,31 +0,0 @@
-import { Text } from "ink";
-import type { ColumnProps } from "./types";
-
-const clamp = (value: number, minimum: number, maximum: number): number =>
-  Math.min(Math.max(value, minimum), maximum);
-
-export interface BarColumnProps extends ColumnProps {
-  readonly width: number;
-}
-
-export const BarColumn = ({ task, width }: BarColumnProps) => {
-  if (task.units._tag !== "DeterminateTaskUnits") {
-    return <Text />;
-  }
-
-  const barWidth = Math.max(1, Math.floor(width));
-  const safeTotal = Math.max(1, task.units.total);
-  const ratio = task.status === "done" ? 1 : clamp(task.units.completed / safeTotal, 0, 1);
-  const filled = Math.round(barWidth * ratio);
-  const empty = Math.max(0, barWidth - filled);
-  const bar = `${"━".repeat(filled)}${"─".repeat(empty)}`;
-
-  const color =
-    task.status === "failed" ? "red" : task.status === "done" ? "green" : "blue";
-
-  return (
-    <Text wrap="truncate-end" color={color}>
-      {bar}
-    </Text>
-  );
-};

package/src/ink-renderer/columns/description-column.tsx

@@ -1,7 +0,0 @@
-import { Text } from "ink";
-import { renderTreePrefix } from "../tree";
-import type { ColumnProps } from "./types";
-
-export const DescriptionColumn = ({ task, tree, showTree }: ColumnProps) => (
-  <Text wrap="truncate-end">{`${showTree ? renderTreePrefix(tree) : ""}${task.description}`}</Text>
-);

package/src/ink-renderer/columns/elapsed-column.tsx

@@ -1,7 +0,0 @@
-import { Text } from "ink";
-import { formatElapsed } from "../format";
-import type { ColumnProps } from "./types";
-
-export const ElapsedColumn = ({ task, now }: ColumnProps) => (
-  <Text color="gray">{formatElapsed(task, now)}</Text>
-);

package/src/ink-renderer/columns/eta-column.tsx

@@ -1,18 +0,0 @@
-import { Text } from "ink";
-import { formatEta } from "../format";
-import type { ColumnProps } from "./types";
-
-export const EtaColumn = ({ task, now }: ColumnProps) => {
-  if (task.status !== "running" || task.units._tag !== "DeterminateTaskUnits") {
-    return <Text />;
-  }
-
-  const eta = formatEta(task, now);
-  const text = eta.length > 0 ? `ETA: ${eta}` : "ETA: --";
-
-  return (
-    <Text wrap="truncate-end" color="gray">
-      {text}
-    </Text>
-  );
-};

package/src/ink-renderer/columns/index.ts

@@ -1,6 +0,0 @@
-export { AmountColumn } from "./amount-column";
-export { BarColumn } from "./bar-column";
-export { DescriptionColumn } from "./description-column";
-export { ElapsedColumn } from "./elapsed-column";
-export { EtaColumn } from "./eta-column";
-export type { ColumnProps } from "./types";

package/src/ink-renderer/columns/types.ts

@@ -1,11 +0,0 @@
-import type { TaskSnapshot } from "../../types";
-import type { TaskTreeInfo } from "../types";
-
-export interface ColumnProps {
-  readonly task: TaskSnapshot;
-  readonly tree: TaskTreeInfo;
-  readonly now: number;
-  readonly tick: number;
-  readonly isTTY: boolean;
-  readonly showTree: boolean;
-}

package/src/ink-renderer/format.ts

@@ -1,55 +0,0 @@
-import type { TaskSnapshot } from "../types";
-
-export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
-
-export const formatDurationSeconds = (seconds: number): string => {
-  const value = Math.max(0, Math.floor(seconds));
-  if (value < 60) {
-    return `${value}s`;
-  }
-  if (value < 3600) {
-    const mins = Math.floor(value / 60);
-    const secs = value % 60;
-    return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
-  }
-
-  const hours = Math.floor(value / 3600);
-  const mins = Math.floor((value % 3600) / 60);
-  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
-};
-
-export const formatElapsed = (task: TaskSnapshot, now: number): string => {
-  const elapsedMillis = Math.max(0, (task.completedAt ?? now) - task.startedAt);
-  return formatDurationSeconds(elapsedMillis / 1000);
-};
-
-export const formatEta = (task: TaskSnapshot, now: number): string => {
-  if (task.status !== "running" || task.units._tag !== "DeterminateTaskUnits") {
-    return "";
-  }
-
-  const { completed, total } = task.units;
-  const remaining = total - completed;
-  if (completed <= 0 || remaining <= 0) {
-    return "";
-  }
-
-  const elapsedMillis = Math.max(1, now - task.startedAt);
-  const etaMillis = Math.max(0, Math.floor((elapsedMillis / completed) * remaining));
-  return formatDurationSeconds(etaMillis / 1000);
-};
-
-export const formatAmount = (task: TaskSnapshot, tick: number): string => {
-  if (task.units._tag === "DeterminateTaskUnits") {
-    const totalText = `${task.units.total}`;
-    const completedText = `${task.units.completed}`.padStart(totalText.length, " ");
-    return `${completedText}/${totalText}`;
-  }
-
-  if (task.status === "running") {
-    const frameIndex = (task.units.spinnerFrame + tick) % SPINNER_FRAMES.length;
-    return SPINNER_FRAMES[frameIndex] ?? SPINNER_FRAMES[0]!;
-  }
-
-  return task.status === "done" ? "✓" : "✗";
-};

package/src/ink-renderer/index.ts

@@ -1 +0,0 @@
-export { InkRenderer, type InkRendererService } from "./service";

package/src/ink-renderer/layout.ts

@@ -1,145 +0,0 @@
-import { formatAmount, formatElapsed, formatEta } from "./format";
-import { renderTreePrefix } from "./tree";
-import type { TaskRowModel } from "./types";
-
-export const DEFAULT_BAR_WIDTH = 20;
-const MIN_DESCRIPTION_WIDTH = 8;
-const MIN_BAR_WIDTH = 8;
-const MIN_ELAPSED_WIDTH = 3;
-const MIN_AMOUNT_WIDTH = 1;
-const BASELINE_ROW_WIDTH = 100;
-export const MIN_DESCRIPTION_COLUMNS_FOR_TREE = 24;
-const RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR = Array.from("59m 59s").length;
-const RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR = Array.from("ETA: 59m 59s").length;
-
-const textWidth = (text: string): number => Array.from(text).length;
-
-export interface SharedColumnWidths {
-  readonly row: number;
-  readonly description: number;
-  readonly bar: number;
-  readonly amount: number;
-  readonly elapsed: number;
-  readonly eta: number;
-  readonly showTree: boolean;
-}
-
-const computeWidths = (
-  rows: ReadonlyArray<TaskRowModel>,
-  now: number,
-  tick: number,
-  terminalColumns?: number,
-  includeTree = true,
-): Omit<SharedColumnWidths, "showTree"> => {
-  let hasDeterminate = false;
-  let description = MIN_DESCRIPTION_WIDTH;
-  let amount = 1;
-  let elapsed = RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR;
-  let eta = RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR;
-
-  for (const row of rows) {
-    const { task, tree } = row;
-    const treePrefix = includeTree ? renderTreePrefix(tree) : "";
-    description = Math.max(description, textWidth(`${treePrefix}${task.description}`));
-
-    if (task.units._tag === "DeterminateTaskUnits") {
-      hasDeterminate = true;
-    }
-
-    amount = Math.max(amount, textWidth(formatAmount(task, tick)));
-    elapsed = Math.max(elapsed, textWidth(formatElapsed(task, now)));
-
-    if (task.status === "running" && task.units._tag === "DeterminateTaskUnits") {
-      const etaValue = formatEta(task, now);
-      const etaText = `ETA: ${etaValue.length > 0 ? etaValue : "--"}`;
-      eta = Math.max(eta, textWidth(etaText));
-    }
-  }
-
-  const bar = hasDeterminate ? DEFAULT_BAR_WIDTH : 0;
-  let widths = {
-    description,
-    bar,
-    amount,
-    elapsed,
-    eta,
-  };
-
-  const visible = (w: typeof widths): Array<number> =>
-    [w.description, w.bar, w.amount, w.elapsed, w.eta].filter((width) => width > 0);
-  const total = (w: typeof widths): number => {
-    const cols = visible(w);
-    return cols.reduce((sum, width) => sum + width, 0) + Math.max(0, cols.length - 1);
-  };
-
-  const baselineTarget = Math.max(BASELINE_ROW_WIDTH, total(widths));
-  const target =
-    terminalColumns === undefined
-      ? baselineTarget
-      : Math.max(1, Math.min(Math.max(1, Math.floor(terminalColumns)), baselineTarget));
-
-  if (total(widths) < target) {
-    widths.description += target - total(widths);
-  } else if (total(widths) > target) {
-    let overflow = total(widths) - target;
-
-    const reduceBy = (key: keyof typeof widths, min: number) => {
-      if (overflow <= 0) {
-        return;
-      }
-      const current = widths[key];
-      if (current <= min) {
-        return;
-      }
-      const reducible = current - min;
-      const delta = Math.min(reducible, overflow);
-      widths = { ...widths, [key]: current - delta };
-      overflow -= delta;
-    };
-
-    // Compress the description first, then optional columns.
-    reduceBy("description", MIN_DESCRIPTION_WIDTH);
-    reduceBy("eta", 0);
-    reduceBy("bar", MIN_BAR_WIDTH);
-    reduceBy("bar", 0);
-    reduceBy("elapsed", MIN_ELAPSED_WIDTH);
-    reduceBy("amount", MIN_AMOUNT_WIDTH);
-    reduceBy("description", 0);
-
-    if (total(widths) < target) {
-      widths.description += target - total(widths);
-    }
-  }
-
-  const rowWidth = total(widths);
-
-  return {
-    row: rowWidth,
-    description: widths.description,
-    bar: widths.bar,
-    amount: widths.amount,
-    elapsed: widths.elapsed,
-    eta: widths.eta,
-  };
-};
-
-export const computeSharedColumnWidths = (
-  rows: ReadonlyArray<TaskRowModel>,
-  now: number,
-  tick: number,
-  terminalColumns?: number,
-): SharedColumnWidths => {
-  const withTree = computeWidths(rows, now, tick, terminalColumns, true);
-  if (withTree.description >= MIN_DESCRIPTION_COLUMNS_FOR_TREE) {
-    return {
-      ...withTree,
-      showTree: true,
-    };
-  }
-
-  const withoutTree = computeWidths(rows, now, tick, terminalColumns, false);
-  return {
-    ...withoutTree,
-    showTree: false,
-  };
-};

package/src/ink-renderer/model.ts

@@ -1,24 +0,0 @@
-import type { TaskStore } from "../types";
-import type { OrderedTask, TaskRowModel } from "./types";
-import { computeTreeInfo } from "./tree";
-
-const orderedVisibleTasks = (store: TaskStore): ReadonlyArray<OrderedTask> =>
-  store.renderOrder.flatMap((row) => {
-    const snapshot = store.tasks.get(row.id);
-    if (!snapshot || (snapshot.transient && snapshot.status !== "running")) {
-      return [];
-    }
-
-    return [
-      {
-        snapshot,
-        depth: row.depth,
-      },
-    ];
-  });
-
-export const toTaskRows = (store: TaskStore): ReadonlyArray<TaskRowModel> =>
-  computeTreeInfo(orderedVisibleTasks(store)).map((entry) => ({
-    task: entry.snapshot,
-    tree: entry.tree,
-  }));