@owloops/claude-powerline 1.24.3 → 1.25.0

package/src/tui/grid.ts

@@ -0,0 +1,712 @@
+import type {
+  GridCell,
+  AlignValue,
+  TuiGridBreakpoint,
+  TuiGridConfig,
+  BoxChars,
+} from "./types";
+import { visibleLength } from "../utils/terminal";
+import { truncateAnsi, padRight, padLeft, padCenter } from "./primitives";
+
+export const DIVIDER = "---";
+export const EMPTY_CELL = ".";
+
+// Segments whose content is resolved after column widths are known (lateResolve).
+// Auto-width measurement must skip these to avoid locking columns to placeholder widths.
+export const LATE_RESOLVE_SEGMENTS = new Set([
+  "context",
+  "context.bar",
+  "block.bar",
+  "weekly.bar",
+]);
+
+function isDividerRow(row: GridCell[]): boolean {
+  return row.length === 1 && row[0]!.segment === DIVIDER;
+}
+
+function parseFr(colDef: string): number {
+  if (!colDef.endsWith("fr")) return 0;
+  const fr = parseInt(colDef.replace("fr", ""), 10);
+  return !isNaN(fr) && fr > 0 ? fr : 0;
+}
+
+function distributeExact(
+  total: number,
+  targets: number[],
+  widths: number[],
+): void {
+  const base = Math.floor(total / targets.length);
+  let extra = total - base * targets.length;
+  for (const idx of targets) {
+    widths[idx] = widths[idx]! + base + (extra > 0 ? 1 : 0);
+    if (extra > 0) extra--;
+  }
+}
+
+function spanCellWidth(
+  colWidths: number[],
+  startIdx: number,
+  spanSize: number,
+  sepWidth: number,
+): number {
+  let width = 0;
+  for (let j = 0; j < spanSize; j++) {
+    width += colWidths[startIdx + j] ?? 0;
+  }
+  if (spanSize > 1) {
+    width += (spanSize - 1) * sepWidth;
+  }
+  return width;
+}
+
+export interface GridResult {
+  lines: string[];
+  panelWidth: number;
+}
+
+// --- Breakpoint Selection ---
+
+export function selectBreakpoint(
+  breakpoints: TuiGridBreakpoint[],
+  panelWidth: number,
+): TuiGridBreakpoint {
+  let best: TuiGridBreakpoint | undefined;
+  for (const bp of breakpoints) {
+    if (panelWidth >= bp.minWidth) {
+      if (!best || bp.minWidth > best.minWidth) {
+        best = bp;
+      }
+    }
+  }
+  if (best) return best;
+
+  // Fallback to smallest minWidth
+  let smallest = breakpoints[0]!;
+  for (let i = 1; i < breakpoints.length; i++) {
+    if (breakpoints[i]!.minWidth < smallest.minWidth) {
+      smallest = breakpoints[i]!;
+    }
+  }
+  return smallest;
+}
+
+// --- Area Parsing ---
+
+export function parseAreas(areas: string[]): GridCell[][] {
+  const matrix: GridCell[][] = [];
+
+  for (const row of areas) {
+    const trimmed = row.trim();
+
+    // Divider row
+    if (trimmed === DIVIDER) {
+      matrix.push([{ segment: DIVIDER, spanStart: true, spanSize: 1 }]);
+      continue;
+    }
+
+    const cells = trimmed.split(/\s+/);
+    const rowCells: GridCell[] = [];
+
+    let i = 0;
+    while (i < cells.length) {
+      const name = cells[i]!;
+      let spanSize = 1;
+
+      // Count adjacent cells with the same name
+      while (i + spanSize < cells.length && cells[i + spanSize] === name) {
+        spanSize++;
+      }
+
+      // First cell of the span
+      rowCells.push({ segment: name, spanStart: true, spanSize });
+
+      // Continuation cells
+      for (let j = 1; j < spanSize; j++) {
+        rowCells.push({ segment: name, spanStart: false, spanSize: 0 });
+      }
+
+      i += spanSize;
+    }
+
+    matrix.push(rowCells);
+  }
+
+  return matrix;
+}
+
+// --- Matrix Culling ---
+
+export function cullMatrix(
+  matrix: GridCell[][],
+  resolvedData: Record<string, string>,
+): GridCell[][] {
+  // Phase 1: Replace cells whose segment has no data with "."
+  const processed = matrix.map((row) => {
+    if (isDividerRow(row)) return row;
+
+    return row.map((cell) => {
+      if (cell.segment === EMPTY_CELL || cell.segment === DIVIDER) return cell;
+
+      const data = resolvedData[cell.segment];
+      if (!data) {
+        return { segment: EMPTY_CELL, spanStart: true, spanSize: 1 };
+      }
+      return cell;
+    });
+  });
+
+  // Phase 2: Re-calculate spans after emptying cells
+  // When a span-start cell was emptied, all its continuation cells are already individual "." cells.
+  // But when continuation cells were emptied, the span-start needs fixing.
+  const respanned = processed.map((row) => {
+    if (isDividerRow(row)) return row;
+
+    // Rebuild spans from scratch
+    const cells = row.map((c) => c.segment);
+    const rebuilt: GridCell[] = [];
+
+    let i = 0;
+    while (i < cells.length) {
+      const name = cells[i]!;
+      let spanSize = 1;
+
+      while (i + spanSize < cells.length && cells[i + spanSize] === name) {
+        spanSize++;
+      }
+
+      rebuilt.push({ segment: name, spanStart: true, spanSize });
+      for (let j = 1; j < spanSize; j++) {
+        rebuilt.push({ segment: name, spanStart: false, spanSize: 0 });
+      }
+
+      i += spanSize;
+    }
+
+    return rebuilt;
+  });
+
+  // Phase 3: Remove rows that are entirely "."
+  const nonEmpty = respanned.filter((row) => {
+    if (isDividerRow(row)) return true;
+    return row.some((cell) => cell.segment !== EMPTY_CELL);
+  });
+
+  // Phase 4: Collapse adjacent dividers into one, remove leading/trailing dividers
+  const cleaned: GridCell[][] = [];
+  for (let i = 0; i < nonEmpty.length; i++) {
+    const row = nonEmpty[i]!;
+    if (!isDividerRow(row)) {
+      cleaned.push(row);
+      continue;
+    }
+
+    // Skip dividers at top
+    if (cleaned.length === 0) continue;
+
+    // Collapse adjacent dividers: skip if last pushed row is already a divider
+    if (isDividerRow(cleaned[cleaned.length - 1]!)) continue;
+
+    cleaned.push(row);
+  }
+
+  // Remove trailing divider
+  if (cleaned.length > 0 && isDividerRow(cleaned[cleaned.length - 1]!)) {
+    cleaned.pop();
+  }
+
+  return cleaned;
+}
+
+// --- Column Width Distribution ---
+
+function measureAutoWidths(
+  colCount: number,
+  matrix: GridCell[][],
+  resolvedData: Record<string, string>,
+  lateResolveNames?: ReadonlySet<string>,
+): number[] {
+  const widths = Array.from<number>({ length: colCount }).fill(0);
+  for (const row of matrix) {
+    if (isDividerRow(row)) continue;
+    for (let colIdx = 0; colIdx < row.length; colIdx++) {
+      const cell = row[colIdx]!;
+      if (!cell.spanStart || cell.spanSize !== 1) continue;
+      if (cell.segment === EMPTY_CELL) continue;
+      if (colIdx >= colCount) continue;
+      if (lateResolveNames?.has(cell.segment)) continue;
+      const content = resolvedData[cell.segment] || "";
+      const len = visibleLength(content);
+      if (len > widths[colIdx]!) {
+        widths[colIdx] = len;
+      }
+    }
+  }
+  return widths;
+}
+
+export function calculateColumnWidths(
+  columns: string[],
+  matrix: GridCell[][],
+  resolvedData: Record<string, string>,
+  contentWidth: number,
+  separatorWidth: number,
+  lateResolveNames?: ReadonlySet<string>,
+): number[] {
+  const colCount = columns.length;
+  const autoWidths = measureAutoWidths(
+    colCount,
+    matrix,
+    resolvedData,
+    lateResolveNames,
+  );
+  const widths = Array.from<number>({ length: colCount }).fill(0);
+
+  // Phase 1: Apply auto widths
+  for (let i = 0; i < colCount; i++) {
+    if (columns[i] === "auto") {
+      widths[i] = autoWidths[i]!;
+    }
+  }
+
+  // Phase 2: Apply fixed widths
+  for (let i = 0; i < colCount; i++) {
+    const colDef = columns[i]!;
+    if (colDef === "auto") continue;
+    if (colDef.endsWith("fr")) continue;
+
+    const fixed = parseInt(colDef, 10);
+    if (!isNaN(fixed) && fixed > 0) {
+      widths[i] = fixed;
+    }
+  }
+
+  // Clamp auto/fixed widths to >= 1 BEFORE computing fr remaining,
+  // so fr columns account for the clamped minimums in their budget.
+  for (let i = 0; i < colCount; i++) {
+    if (widths[i]! < 1 && !columns[i]!.endsWith("fr")) {
+      widths[i] = 1;
+    }
+  }
+
+  const totalSepWidth = Math.max(0, colCount - 1) * separatorWidth;
+  const usedWidth = widths.reduce((sum, w) => sum + w, 0);
+  const remaining = Math.max(0, contentWidth - usedWidth - totalSepWidth);
+
+  let totalFr = 0;
+  for (const colDef of columns) totalFr += parseFr(colDef);
+
+  if (totalFr > 0) {
+    const perFr = remaining / totalFr;
+    const frCols: number[] = [];
+    let allocatedFr = 0;
+    for (let i = 0; i < colCount; i++) {
+      const fr = parseFr(columns[i]!);
+      if (fr > 0) {
+        const w = Math.floor(perFr * fr);
+        widths[i] = w;
+        allocatedFr += w;
+        frCols.push(i);
+      }
+    }
+    let leftover = remaining - allocatedFr;
+    for (let k = 0; leftover > 0 && k < frCols.length; k++) {
+      widths[frCols[k]!]! += 1;
+      leftover--;
+    }
+  }
+
+  return widths;
+}
+
+export function solveFitContentLayout(
+  columns: string[],
+  matrix: GridCell[][],
+  resolvedData: Record<string, string>,
+  separatorWidth: number,
+  horizontalPadding: number,
+  lateResolveNames?: ReadonlySet<string>,
+): { panelWidth: number; colWidths: number[] } {
+  const colCount = columns.length;
+  const autoWidths = measureAutoWidths(
+    colCount,
+    matrix,
+    resolvedData,
+    lateResolveNames,
+  );
+
+  // Seed from intrinsic non-spanning content and fixed widths
+  const widths = Array.from<number>({ length: colCount });
+  for (let i = 0; i < colCount; i++) {
+    const colDef = columns[i]!;
+    if (colDef !== "auto" && !colDef.endsWith("fr")) {
+      const fixed = parseInt(colDef, 10);
+      widths[i] = !isNaN(fixed) && fixed > 0 ? fixed : autoWidths[i]!;
+    } else {
+      widths[i] = autoWidths[i]!;
+    }
+  }
+
+  // Expand columns to fit spanning cells
+  for (const row of matrix) {
+    if (isDividerRow(row)) continue;
+    for (let i = 0; i < row.length; i++) {
+      const cell = row[i]!;
+      if (!cell.spanStart || cell.spanSize <= 1 || cell.segment === EMPTY_CELL)
+        continue;
+
+      const content = resolvedData[cell.segment] || "";
+      const contentLen = visibleLength(content);
+      const sw = spanCellWidth(widths, i, cell.spanSize, separatorWidth);
+
+      if (contentLen > sw) {
+        const deficit = contentLen - sw;
+        const frCols: number[] = [];
+        for (let j = 0; j < cell.spanSize; j++) {
+          if (parseFr(columns[i + j]!) > 0) frCols.push(i + j);
+        }
+        if (frCols.length > 0) {
+          distributeExact(deficit, frCols, widths);
+        } else {
+          const allCols: number[] = [];
+          for (let j = 0; j < cell.spanSize; j++) allCols.push(i + j);
+          distributeExact(deficit, allCols, widths);
+        }
+      }
+    }
+  }
+
+  // Clamp all widths to >= 1
+  for (let i = 0; i < colCount; i++) {
+    if (widths[i]! < 1) widths[i] = 1;
+  }
+
+  let naturalWidth = 0;
+  for (let i = 0; i < colCount; i++) {
+    naturalWidth += widths[i]!;
+  }
+
+  const totalSepWidth = Math.max(0, colCount - 1) * separatorWidth;
+  const extraWallPad = Math.max(0, 1 - horizontalPadding);
+  const borders = 2 + extraWallPad * 2; // 2 box chars + extra wall padding
+  const cellPadding = colCount * horizontalPadding * 2;
+  return {
+    panelWidth: naturalWidth + totalSepWidth + borders + cellPadding,
+    colWidths: widths,
+  };
+}
+
+// --- Cell Rendering ---
+
+function alignContent(text: string, width: number, align: AlignValue): string {
+  switch (align) {
+    case "right":
+      return padLeft(text, width);
+    case "center":
+      return padCenter(text, width);
+    case "left":
+    default:
+      return padRight(text, width);
+  }
+}
+
+export function renderGridRow(
+  row: GridCell[],
+  colWidths: number[],
+  align: AlignValue[],
+  resolvedData: Record<string, string>,
+  separator: string,
+  horizontalPadding = 0,
+  padShrink?: number[],
+): string {
+  const parts: string[] = [];
+  const sepWidth = visibleLength(separator);
+  const hPad = horizontalPadding;
+
+  for (let i = 0; i < row.length; i++) {
+    const cell = row[i]!;
+    if (!cell.spanStart) continue;
+
+    const cellWidth = spanCellWidth(colWidths, i, cell.spanSize, sepWidth);
+
+    // Compute per-cell padding from column shrink values
+    const lastCol = i + cell.spanSize - 1;
+    const leftShrink = align[i] === "right" ? (padShrink?.[i] ?? 0) : 0;
+    const rightShrink =
+      align[lastCol] === "left" ? (padShrink?.[lastCol] ?? 0) : 0;
+    const leftPad = hPad - leftShrink;
+    const rightPad = hPad - rightShrink;
+
+    // Inner padding for spanning cells (accounts for shrink of internal columns)
+    let innerPad = 0;
+    for (let j = i; j < lastCol; j++) {
+      const rShrink = align[j] === "left" ? (padShrink?.[j] ?? 0) : 0;
+      const lShrink = align[j + 1] === "right" ? (padShrink?.[j + 1] ?? 0) : 0;
+      innerPad += hPad - rShrink + (hPad - lShrink);
+    }
+    const contentWidth = cellWidth + innerPad;
+
+    if (cell.segment === EMPTY_CELL) {
+      parts.push(" ".repeat(contentWidth + leftPad + rightPad));
+    } else {
+      const content = resolvedData[cell.segment] || "";
+      const truncated = truncateAnsi(content, contentWidth);
+      const cellAlign = align[i] || "left";
+      const aligned = alignContent(truncated, contentWidth, cellAlign);
+      const lp = leftPad > 0 ? " ".repeat(leftPad) : "";
+      const rp = rightPad > 0 ? " ".repeat(rightPad) : "";
+      parts.push(lp + aligned + rp);
+    }
+  }
+
+  return parts.join(separator);
+}
+
+// --- Divider Rendering ---
+
+export function renderGridDivider(
+  box: BoxChars,
+  innerWidth: number,
+  dividerChar?: string,
+): string {
+  const ch = dividerChar || box.horizontal;
+  return box.teeLeft + ch.repeat(innerWidth) + box.teeRight;
+}
+
+// --- Main Grid Render ---
+
+export function renderGrid(
+  gridConfig: TuiGridConfig,
+  resolvedData: Record<string, string>,
+  box: BoxChars,
+  rawTerminalWidth: number,
+  lateResolve?: (segment: string, cellWidth: number) => string | undefined,
+): GridResult {
+  const minWidth = gridConfig.minWidth ?? 32;
+  const maxWidth = gridConfig.maxWidth ?? Infinity;
+  const colSep = gridConfig.separator?.column ?? "  ";
+  const dividerChar = gridConfig.separator?.divider;
+  const sepWidth = visibleLength(colSep);
+  const fitContent = gridConfig.fitContent ?? false;
+  const hPad = gridConfig.padding?.horizontal ?? 0;
+
+  // Breakpoint selection always uses available width (terminal - reserve)
+  const widthReserve = gridConfig.widthReserve ?? 45;
+  const availableWidth = Math.min(
+    maxWidth,
+    Math.max(minWidth, rawTerminalWidth - widthReserve),
+  );
+  const bp = selectBreakpoint(gridConfig.breakpoints, availableWidth);
+
+  // Panel width for rendering
+  let panelWidth: number;
+  if (fitContent) {
+    panelWidth =
+      maxWidth !== Infinity
+        ? Math.min(rawTerminalWidth, maxWidth)
+        : rawTerminalWidth;
+  } else {
+    panelWidth = availableWidth;
+  }
+
+  // Parse areas
+  const rawMatrix = parseAreas(bp.areas);
+
+  // Cull empty cells/rows
+  const matrix = cullMatrix(rawMatrix, resolvedData);
+
+  if (matrix.length === 0) {
+    return { lines: [], panelWidth };
+  }
+
+  let colWidths: number[];
+
+  // Collect late-resolve segment names (including user-defined templates)
+  const lateNames = new Set(LATE_RESOLVE_SEGMENTS);
+  if (gridConfig.segments) {
+    for (const key of Object.keys(gridConfig.segments)) {
+      lateNames.add(key);
+    }
+  }
+
+  if (fitContent) {
+    const solved = solveFitContentLayout(
+      bp.columns,
+      matrix,
+      resolvedData,
+      sepWidth,
+      hPad,
+      lateNames,
+    );
+    panelWidth = Math.min(maxWidth, Math.max(minWidth, solved.panelWidth));
+    colWidths = solved.colWidths;
+
+    // Redistribute surplus (from minWidth or maxWidth clamping) into fr columns
+    const surplus = panelWidth - solved.panelWidth;
+    if (surplus > 0) {
+      let totalFr = 0;
+      for (const colDef of bp.columns) totalFr += parseFr(colDef);
+      if (totalFr > 0) {
+        const frCols: number[] = [];
+        let allocated = 0;
+        for (let i = 0; i < colWidths.length; i++) {
+          const fr = parseFr(bp.columns[i]!);
+          if (fr > 0) {
+            const add = Math.floor((surplus * fr) / totalFr);
+            colWidths[i]! += add;
+            allocated += add;
+            frCols.push(i);
+          }
+        }
+        let leftover = surplus - allocated;
+        for (let k = 0; leftover > 0 && k < frCols.length; k++) {
+          colWidths[frCols[k]!]! += 1;
+          leftover--;
+        }
+      }
+    }
+  } else {
+    const innerW = panelWidth - 2;
+    const ewp = Math.max(0, 1 - hPad);
+    const contentW = innerW - ewp * 2 - bp.columns.length * hPad * 2;
+    colWidths = calculateColumnWidths(
+      bp.columns,
+      matrix,
+      resolvedData,
+      contentW,
+      sepWidth,
+      lateNames,
+    );
+  }
+
+  const innerWidth = panelWidth - 2;
+  // When hPad >= 1, cell padding replaces the base 1-space wall padding
+  const wallPad = Math.max(1, hPad);
+  const extraWallPad = wallPad - hPad; // 1 when hPad=0, 0 when hPad>=1
+  const wallPadStr = extraWallPad > 0 ? " ".repeat(extraWallPad) : "";
+  const contentWidth = innerWidth - extraWallPad * 2;
+
+  // Alignment defaults
+  const align: AlignValue[] =
+    bp.align || bp.columns.map(() => "left" as AlignValue);
+
+  // Adaptive padding: absorb alignment gaps into padding, redistribute savings to fr columns.
+  // padShrink[col] = how much of hPad is absorbed by existing alignment gap on the aligned side.
+  const padShrink = new Array<number>(bp.columns.length).fill(0);
+  if (hPad > 0) {
+    const maxContent = new Array<number>(bp.columns.length).fill(0);
+    for (const row of matrix) {
+      if (isDividerRow(row)) continue;
+      for (let ci = 0; ci < row.length; ci++) {
+        const cell = row[ci]!;
+        if (!cell.spanStart || cell.spanSize !== 1) continue;
+        if (cell.segment === EMPTY_CELL) continue;
+        if (lateNames.has(cell.segment)) continue;
+        const len = visibleLength(resolvedData[cell.segment] || "");
+        if (len > maxContent[ci]!) maxContent[ci] = len;
+      }
+    }
+
+    let totalSavings = 0;
+    for (let ci = 0; ci < bp.columns.length; ci++) {
+      if (parseFr(bp.columns[ci]!) > 0) continue;
+      if (maxContent[ci]! <= 0) continue;
+      const gap = colWidths[ci]! - maxContent[ci]!;
+      if (gap <= 0) continue;
+      padShrink[ci] = Math.min(hPad, gap);
+      totalSavings += padShrink[ci]!;
+    }
+
+    if (totalSavings > 0) {
+      let totalFr = 0;
+      for (const colDef of bp.columns) totalFr += parseFr(colDef);
+      if (totalFr > 0) {
+        const frCols: number[] = [];
+        let allocated = 0;
+        for (let ci = 0; ci < colWidths.length; ci++) {
+          const fr = parseFr(bp.columns[ci]!);
+          if (fr > 0) {
+            const add = Math.floor((totalSavings * fr) / totalFr);
+            colWidths[ci]! += add;
+            allocated += add;
+            frCols.push(ci);
+          }
+        }
+        let leftover = totalSavings - allocated;
+        for (let k = 0; leftover > 0 && k < frCols.length; k++) {
+          colWidths[frCols[k]!]! += 1;
+          leftover--;
+        }
+      }
+    }
+  }
+
+  // Compute span inner padding accounting for per-column shrink
+  function spanInnerPad(colIdx: number, spanSize: number): number {
+    let pad = 0;
+    for (let j = colIdx; j < colIdx + spanSize - 1; j++) {
+      const rShrink = align[j] === "left" ? (padShrink[j] ?? 0) : 0;
+      const lShrink = align[j + 1] === "right" ? (padShrink[j + 1] ?? 0) : 0;
+      pad += hPad - rShrink + (hPad - lShrink);
+    }
+    return pad;
+  }
+
+  // Late resolve: re-resolve width-dependent segments now that cell widths are known
+  if (lateResolve) {
+    const seen = new Set<string>();
+    for (const row of matrix) {
+      if (isDividerRow(row)) continue;
+      for (let i = 0; i < row.length; i++) {
+        const cell = row[i]!;
+        if (
+          !cell.spanStart ||
+          cell.segment === EMPTY_CELL ||
+          cell.segment === DIVIDER
+        )
+          continue;
+        if (seen.has(cell.segment)) continue;
+        seen.add(cell.segment);
+
+        const cellWidth = spanCellWidth(colWidths, i, cell.spanSize, sepWidth);
+        const innerPad = spanInnerPad(i, cell.spanSize);
+        const content = lateResolve(cell.segment, cellWidth + innerPad);
+        if (content !== undefined) {
+          resolvedData[cell.segment] = content;
+        }
+      }
+    }
+  }
+
+  // Post-lateResolve culling: segments that resolved to empty after lateResolve
+  // can leave orphaned rows and dividers. Re-cull the matrix.
+  const finalMatrix = cullMatrix(matrix, resolvedData);
+
+  if (finalMatrix.length === 0) {
+    return { lines: [], panelWidth };
+  }
+
+  // Render rows
+  const lines: string[] = [];
+  for (const row of finalMatrix) {
+    if (isDividerRow(row)) {
+      lines.push(renderGridDivider(box, innerWidth, dividerChar));
+    } else {
+      const rowStr = renderGridRow(
+        row,
+        colWidths,
+        align,
+        resolvedData,
+        colSep,
+        hPad,
+        padShrink,
+      );
+      const truncated = truncateAnsi(rowStr, contentWidth);
+      const padded = padRight(truncated, contentWidth);
+      lines.push(
+        box.vertical + wallPadStr + padded + wallPadStr + box.vertical,
+      );
+    }
+  }
+
+  return { lines, panelWidth };
+}

package/src/tui/index.ts

@@ -0,0 +1,4 @@
+export type { BoxChars, TuiData } from "./types";
+
+export { renderTuiPanel } from "./renderer";
+export type { TuiPanelOptions } from "./renderer";