effective-progress 0.4.2 → 0.5.0

package/src/types.ts

@@ -1,75 +1,4 @@
 import { Brand, Context, Effect, Option, Schema } from "effect";
-import type { PartialDeep } from "type-fest";
-import type { ProgressColumn } from "./renderer";
-
-export const RendererConfigSchema = Schema.Struct({
-  disableUserInput: Schema.Boolean,
-  renderIntervalMillis: Schema.Number,
-  maxLogLines: Schema.optional(Schema.Number),
-  nonTtyUpdateStep: Schema.Number,
-  width: Schema.Union(Schema.Number, Schema.Literal("fullwidth")),
-  columnGap: Schema.Number,
-  columns: Schema.Array(Schema.Unknown),
-});
-export type RendererConfigShape = {
-  readonly disableUserInput: boolean;
-  readonly renderIntervalMillis: number;
-  readonly maxLogLines?: 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),
-  barWidth: Schema.Number,
-  fillChar: Schema.String,
-  emptyChar: Schema.String,
-  leftBracket: Schema.String,
-  rightBracket: Schema.String,
-});
-export type ProgressBarConfigShape = typeof ProgressBarConfigSchema.Type;
-export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarConfigSchema);
-
-export const defaultRendererConfig: RendererConfigShape = {
-  disableUserInput: true,
-  renderIntervalMillis: 100, // 10 FPS
-  maxLogLines: 0,
-  nonTtyUpdateStep: 5,
-  width: 120,
-  columnGap: 1,
-  columns: [],
-};
-
-export const defaultProgressBarConfig: ProgressBarConfigShape = {
-  spinnerFrames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
-  barWidth: 40,
-  fillChar: "━",
-  emptyChar: "─",
-  leftBracket: "",
-  rightBracket: "",
-};
-
-export class RendererConfig extends Context.Tag("stromseng.dev/effective-progress/RendererConfig")<
-  RendererConfig,
-  PartialDeep<RendererConfigShape>
->() {}
-
-export class ProgressBarConfig extends Context.Tag(
-  "stromseng.dev/effective-progress/ProgressBarConfig",
-)<ProgressBarConfig, PartialDeep<ProgressBarConfigShape>>() {}
 
 const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
 
@@ -85,7 +14,6 @@ export interface AddTaskOptions {
   readonly total?: number;
   readonly transient?: boolean;
   readonly parentId?: TaskId;
-  readonly progressbar?: PartialDeep<ProgressBarConfigShape>;
 }
 
 export interface UpdateTaskOptions {
@@ -123,7 +51,6 @@ export class TaskSnapshot extends Schema.TaggedClass<TaskSnapshot>()("TaskSnapsh
   status: TaskStatusSchema,
   transient: Schema.Boolean,
   units: TaskUnitsSchema,
-  config: ProgressBarConfigSchema,
   startedAt: Schema.Number,
   completedAt: Schema.NullOr(Schema.Number),
 }) {}

package/src/console.ts

@@ -1,85 +0,0 @@
-import { Console, Effect } from "effect";
-import { formatWithOptions } from "node:util";
-
-export const makeProgressConsole = (
-  progressLog: (...args: ReadonlyArray<unknown>) => Effect.Effect<void, never, never>,
-  outerConsole: Console.Console,
-): Console.Console => {
-  const log = (...args: ReadonlyArray<unknown>) => progressLog(...args);
-  const unsafeLog = (...args: ReadonlyArray<unknown>) => {
-    Effect.runFork(progressLog(...args));
-  };
-
-  const delegate = (effect: Effect.Effect<void, never, never>) => effect;
-
-  return Console.Console.of({
-    [Console.TypeId]: Console.TypeId,
-    assert(condition, ...args) {
-      return condition ? Effect.void : log("Assertion failed:", ...args);
-    },
-    clear: Effect.void,
-    count: (_label) => Effect.void,
-    countReset: (_label) => Effect.void,
-    debug: (...args) => log(...args),
-    dir: (item, options) => log(formatWithOptions(options ?? {}, "%O", item)),
-    dirxml: (...args) => log(...args),
-    error: (...args) => log(...args),
-    group: (...args) => log(...args),
-    groupEnd: Effect.void,
-    info: (...args) => log(...args),
-    log: (...args) => log(...args),
-    table: (tabularData, properties) => log(tabularData, properties),
-    time: (_label) => Effect.void,
-    timeEnd: (_label) => Effect.void,
-    timeLog: (_label, ...args) => log(...args),
-    trace: (...args) => delegate(outerConsole.trace(...args)),
-    warn: (...args) => log(...args),
-    unsafe: {
-      assert(condition, ...args) {
-        if (!condition) unsafeLog("Assertion failed:", ...args);
-      },
-      clear() {},
-      count(_label) {},
-      countReset(_label) {},
-      debug(...args) {
-        unsafeLog(...args);
-      },
-      dir(item, options) {
-        unsafeLog(formatWithOptions(options ?? {}, "%O", item));
-      },
-      dirxml(...args) {
-        unsafeLog(...args);
-      },
-      error(...args) {
-        unsafeLog(...args);
-      },
-      group(...args) {
-        unsafeLog(...args);
-      },
-      groupCollapsed(...args) {
-        unsafeLog(...args);
-      },
-      groupEnd() {},
-      info(...args) {
-        unsafeLog(...args);
-      },
-      log(...args) {
-        unsafeLog(...args);
-      },
-      table(tabularData, properties) {
-        unsafeLog(tabularData, properties);
-      },
-      time(_label) {},
-      timeEnd(_label) {},
-      timeLog(_label, ...args) {
-        unsafeLog(...args);
-      },
-      trace(...args) {
-        outerConsole.unsafe.trace(...args);
-      },
-      warn(...args) {
-        unsafeLog(...args);
-      },
-    },
-  });
-};

package/src/renderer/ansi.ts

@@ -1,138 +0,0 @@
-import type { CellWrapMode } from "./types";
-
-const ESC = String.fromCharCode(27);
-const ANSI_PATTERN = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, "g");
-const RESET_ANSI = "\x1b[0m";
-
-interface AnsiToken {
-  readonly kind: "ansi" | "char";
-  readonly value: string;
-}
-
-const textWidth = (text: string): number => Array.from(text).length;
-
-export const stripAnsi = (text: string): string => text.replace(ANSI_PATTERN, "");
-
-export const visibleWidth = (text: string): number => textWidth(stripAnsi(text));
-
-const tokenizeAnsi = (text: string): ReadonlyArray<AnsiToken> => {
-  const tokens: Array<AnsiToken> = [];
-  let i = 0;
-
-  while (i < text.length) {
-    if (text[i] === "\x1b" && text[i + 1] === "[") {
-      let j = i + 2;
-      while (j < text.length) {
-        const code = text.charCodeAt(j);
-        j += 1;
-        if (code >= 0x40 && code <= 0x7e) {
-          break;
-        }
-      }
-      tokens.push({ kind: "ansi", value: text.slice(i, j) });
-      i = j;
-      continue;
-    }
-
-    const codePoint = text.codePointAt(i);
-    if (codePoint === undefined) {
-      break;
-    }
-
-    const char = String.fromCodePoint(codePoint);
-    tokens.push({ kind: "char", value: char });
-    i += char.length;
-  }
-
-  return tokens;
-};
-
-const fitPlainText = (text: string, width: number, wrapMode: CellWrapMode): string => {
-  const target = Math.max(0, Math.floor(width));
-  if (target <= 0) {
-    return "";
-  }
-
-  const chars = Array.from(text);
-  let result = text;
-
-  if (chars.length > target) {
-    if (wrapMode === "ellipsis") {
-      result = target === 1 ? "…" : `${chars.slice(0, target - 1).join("")}…`;
-    } else {
-      result = chars.slice(0, target).join("");
-    }
-  }
-
-  const currentWidth = textWidth(result);
-  if (currentWidth < target) {
-    result += " ".repeat(target - currentWidth);
-  }
-
-  return result;
-};
-
-const fitAnsiText = (text: string, width: number, wrapMode: CellWrapMode): string => {
-  const target = Math.max(0, Math.floor(width));
-  if (target <= 0) {
-    return "";
-  }
-
-  const tokens = tokenizeAnsi(text);
-  const totalVisible = tokens.reduce((sum, token) => sum + (token.kind === "char" ? 1 : 0), 0);
-
-  if (totalVisible <= target) {
-    const padBy = target - totalVisible;
-    return padBy > 0 ? `${text}${" ".repeat(padBy)}` : text;
-  }
-
-  const keepVisible = wrapMode === "ellipsis" ? Math.max(0, target - 1) : target;
-  let visible = 0;
-  let sawAnsi = false;
-  let output = "";
-
-  for (const token of tokens) {
-    if (token.kind === "ansi") {
-      sawAnsi = true;
-      if (keepVisible > 0 && visible <= keepVisible) {
-        output += token.value;
-      }
-      continue;
-    }
-
-    if (visible >= keepVisible) {
-      break;
-    }
-
-    output += token.value;
-    visible += 1;
-  }
-
-  if (wrapMode === "ellipsis" && target > 0) {
-    output += "…";
-  }
-
-  if (sawAnsi && !output.endsWith(RESET_ANSI)) {
-    output += RESET_ANSI;
-  }
-
-  const padBy = target - visibleWidth(output);
-  if (padBy > 0) {
-    output += " ".repeat(padBy);
-  }
-
-  return output;
-};
-
-export const fitRenderedText = (
-  text: string,
-  width: number,
-  wrapMode: CellWrapMode,
-  isTTY: boolean,
-): string => {
-  const raw = isTTY ? text : stripAnsi(text);
-  if (!isTTY || raw.indexOf("\x1b[") === -1) {
-    return fitPlainText(raw, width, wrapMode);
-  }
-  return fitAnsiText(raw, width, wrapMode);
-};

package/src/renderer/types.ts

@@ -1,67 +0,0 @@
-import type { TaskSnapshot } from "../types";
-
-/**
- * Defines how a column claims width during the shrink/fit stage.
- */
-export type ColumnTrack =
-  | {
-      readonly _tag: "Auto";
-    }
-  | {
-      readonly _tag: "Fixed";
-      readonly width: number;
-    }
-  | {
-      readonly _tag: "Fraction";
-      readonly weight: number;
-    };
-
-export const Track = {
-  auto: (): ColumnTrack => ({ _tag: "Auto" }),
-  fixed: (width: number): ColumnTrack => ({
-    _tag: "Fixed",
-    width: Math.max(0, Math.floor(width)),
-  }),
-  fr: (weight = 1): ColumnTrack => ({
-    _tag: "Fraction",
-    weight: Math.max(0.001, weight),
-  }),
-} as const;
-
-/**
- * Tree relationship metadata for rendering connectors.
- */
-export interface TaskTreeInfo {
-  readonly depth: number;
-  readonly hasNextSibling: boolean;
-  readonly hasChildren: boolean;
-  readonly ancestorHasNextSibling: ReadonlyArray<boolean>;
-}
-
-export type CellWrapMode = "truncate" | "ellipsis";
-
-export interface ProgressColumnContext {
-  readonly task: TaskSnapshot;
-  readonly depth: number;
-  readonly tree: TaskTreeInfo;
-  readonly now: number;
-  readonly tick: number;
-  readonly isTTY: boolean;
-}
-
-export interface ProgressColumnVariant {
-  readonly measure?: (context: ProgressColumnContext) => number;
-  readonly render: (context: ProgressColumnContext, width: number) => string;
-}
-
-export interface ProgressColumn {
-  readonly id: string;
-  readonly track?: ColumnTrack;
-  readonly minWidth?: number;
-  readonly maxWidth?: number;
-  readonly collapsePriority?: number;
-  readonly wrapMode?: CellWrapMode;
-  readonly measure?: (context: ProgressColumnContext) => number;
-  readonly render: (context: ProgressColumnContext, width: number) => string;
-  readonly variants?: (context: ProgressColumnContext) => ReadonlyArray<ProgressColumnVariant>;
-}