claude-code/utils/staticRender.tsx

import { c as _c } from "react/compiler-runtime";
import * as React from 'react';
import { useLayoutEffect } from 'react';
import { PassThrough } from 'stream';
import stripAnsi from 'strip-ansi';
import { render, useApp } from '../ink.js';

// This is a workaround for the fact that Ink doesn't support multiple <Static>
// components in the same render tree. Instead of using a <Static> we just render
// the component to a string and then print it to stdout

/**
 * Wrapper component that exits after rendering.
 * Uses useLayoutEffect to ensure we wait for React's commit phase to complete
 * before exiting. This is more robust than process.nextTick() for React 19's
 * async render cycle.
 */
function RenderOnceAndExit(t0) {
  const $ = _c(5);
  const {
    children
  } = t0;
  const {
    exit
  } = useApp();
  let t1;
  let t2;
  if ($[0] !== exit) {
    t1 = () => {
      const timer = setTimeout(exit, 0);
      return () => clearTimeout(timer);
    };
    t2 = [exit];
    $[0] = exit;
    $[1] = t1;
    $[2] = t2;
  } else {
    t1 = $[1];
    t2 = $[2];
  }
  useLayoutEffect(t1, t2);
  let t3;
  if ($[3] !== children) {
    t3 = <>{children}</>;
    $[3] = children;
    $[4] = t3;
  } else {
    t3 = $[4];
  }
  return t3;
}

// DEC synchronized update markers used by terminals
const SYNC_START = '\x1B[?2026h';
const SYNC_END = '\x1B[?2026l';

/**
 * Extracts content from the first complete frame in Ink's output.
 * Ink with non-TTY stdout outputs multiple frames, each wrapped in DEC synchronized
 * update sequences ([?2026h ... [?2026l). We only want the first frame's content.
 */
function extractFirstFrame(output: string): string {
  const startIndex = output.indexOf(SYNC_START);
  if (startIndex === -1) return output;
  const contentStart = startIndex + SYNC_START.length;
  const endIndex = output.indexOf(SYNC_END, contentStart);
  if (endIndex === -1) return output;
  return output.slice(contentStart, endIndex);
}

/**
 * Renders a React node to a string with ANSI escape codes (for terminal output).
 */
export function renderToAnsiString(node: React.ReactNode, columns?: number): Promise<string> {
  return new Promise(async resolve => {
    let output = '';

    // Capture all writes. Set .columns so Ink (ink.tsx:~165) picks up a
    // chosen width instead of PassThrough's undefined → 80 fallback —
    // useful for rendering at terminal width for file dumps that should
    // match what the user sees on screen.
    const stream = new PassThrough();
    if (columns !== undefined) {
      ;
      (stream as unknown as {
        columns: number;
      }).columns = columns;
    }
    stream.on('data', chunk => {
      output += chunk.toString();
    });

    // Render the component wrapped in RenderOnceAndExit
    // Non-TTY stdout (PassThrough) gives full-frame output instead of diffs
    const instance = await render(<RenderOnceAndExit>{node}</RenderOnceAndExit>, {
      stdout: stream as unknown as NodeJS.WriteStream,
      patchConsole: false
    });

    // Wait for the component to exit naturally
    await instance.waitUntilExit();

    // Extract only the first frame's content to avoid duplication
    // (Ink outputs multiple frames in non-TTY mode)
    await resolve(extractFirstFrame(output));
  });
}

/**
 * Renders a React node to a plain text string (ANSI codes stripped).
 */
export async function renderToString(node: React.ReactNode, columns?: number): Promise<string> {
  const output = await renderToAnsiString(node, columns);
  return stripAnsi(output);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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