staticRender.tsx

Full source

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,{"version":3,"names":["React","useLayoutEffect","PassThrough","stripAnsi","render","useApp","RenderOnceAndExit","t0","$","_c","children","exit","t1","t2","timer","setTimeout","clearTimeout","t3","SYNC_START","SYNC_END","extractFirstFrame","output","startIndex","indexOf","contentStart","length","endIndex","slice","renderToAnsiString","node","ReactNode","columns","Promise","resolve","stream","undefined","on","chunk","toString","instance","stdout","NodeJS","WriteStream","patchConsole","waitUntilExit","renderToString"],"sources":["staticRender.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useLayoutEffect } from 'react'\nimport { PassThrough } from 'stream'\nimport stripAnsi from 'strip-ansi'\nimport { render, useApp } from '../ink.js'\n\n// This is a workaround for the fact that Ink doesn't support multiple <Static>\n// components in the same render tree. Instead of using a <Static> we just render\n// the component to a string and then print it to stdout\n\n/**\n * Wrapper component that exits after rendering.\n * Uses useLayoutEffect to ensure we wait for React's commit phase to complete\n * before exiting. This is more robust than process.nextTick() for React 19's\n * async render cycle.\n */\nfunction RenderOnceAndExit({\n  children,\n}: {\n  children: React.ReactNode\n}): React.ReactNode {\n  const { exit } = useApp()\n\n  // useLayoutEffect runs synchronously after React commits DOM mutations.\n  // setTimeout(0) defers exit to allow Ink to flush output to the stream.\n  useLayoutEffect(() => {\n    const timer = setTimeout(exit, 0)\n    return () => clearTimeout(timer)\n  }, [exit])\n\n  return <>{children}</>\n}\n\n// DEC synchronized update markers used by terminals\nconst SYNC_START = '\\x1B[?2026h'\nconst SYNC_END = '\\x1B[?2026l'\n\n/**\n * Extracts content from the first complete frame in Ink's output.\n * Ink with non-TTY stdout outputs multiple frames, each wrapped in DEC synchronized\n * update sequences ([?2026h ... [?2026l). We only want the first frame's content.\n */\nfunction extractFirstFrame(output: string): string {\n  const startIndex = output.indexOf(SYNC_START)\n  if (startIndex === -1) return output\n\n  const contentStart = startIndex + SYNC_START.length\n  const endIndex = output.indexOf(SYNC_END, contentStart)\n  if (endIndex === -1) return output\n\n  return output.slice(contentStart, endIndex)\n}\n\n/**\n * Renders a React node to a string with ANSI escape codes (for terminal output).\n */\nexport function renderToAnsiString(\n  node: React.ReactNode,\n  columns?: number,\n): Promise<string> {\n  return new Promise(async resolve => {\n    let output = ''\n\n    // Capture all writes. Set .columns so Ink (ink.tsx:~165) picks up a\n    // chosen width instead of PassThrough's undefined → 80 fallback —\n    // useful for rendering at terminal width for file dumps that should\n    // match what the user sees on screen.\n    const stream = new PassThrough()\n    if (columns !== undefined) {\n      ;(stream as unknown as { columns: number }).columns = columns\n    }\n    stream.on('data', chunk => {\n      output += chunk.toString()\n    })\n\n    // Render the component wrapped in RenderOnceAndExit\n    // Non-TTY stdout (PassThrough) gives full-frame output instead of diffs\n    const instance = await render(\n      <RenderOnceAndExit>{node}</RenderOnceAndExit>,\n      {\n        stdout: stream as unknown as NodeJS.WriteStream,\n        patchConsole: false,\n      },\n    )\n\n    // Wait for the component to exit naturally\n    await instance.waitUntilExit()\n\n    // Extract only the first frame's content to avoid duplication\n    // (Ink outputs multiple frames in non-TTY mode)\n    await resolve(extractFirstFrame(output))\n  })\n}\n\n/**\n * Renders a React node to a plain text string (ANSI codes stripped).\n */\nexport async function renderToString(\n  node: React.ReactNode,\n  columns?: number,\n): Promise<string> {\n  const output = await renderToAnsiString(node, columns)\n  return stripAnsi(output)\n}\n"],"mappings":"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","ignoreList":[]}