effective-progress 0.4.1 → 0.4.3

package/src/renderer/ansi.ts

@@ -0,0 +1,138 @@
+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/tree.ts

@@ -0,0 +1,68 @@
+import type { TaskSnapshot } from "../types";
+import type { TaskTreeInfo } from "./types";
+
+export interface OrderedTreeTask {
+  readonly snapshot: TaskSnapshot;
+  readonly depth: number;
+}
+
+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<OrderedTreeTask>,
+): ReadonlyArray<OrderedTreeTask & { 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/renderer/types.ts

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