Something went wrong. Try again.
source dump of claude code forked from oppi.li/claude-code
Something went wrong. Try again.
4.6 kB · 184 lines
TypeScript
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185import type { ReactNode } from 'react'import { logForDebugging } from 'src/utils/debug.js'import { Stream } from 'stream'import type { FrameEvent } from './frame.js'import Ink, { type Options as InkOptions } from './ink.js'import instances from './instances.js'
export type RenderOptions = { /** * Output stream where app will be rendered. * * @default process.stdout */ stdout?: NodeJS.WriteStream /** * Input stream where app will listen for input. * * @default process.stdin */ stdin?: NodeJS.ReadStream /** * Error stream. * @default process.stderr */ stderr?: NodeJS.WriteStream /** * Configure whether Ink should listen to Ctrl+C keyboard input and exit the app. This is needed in case `process.stdin` is in raw mode, because then Ctrl+C is ignored by default and process is expected to handle it manually. * * @default true */ exitOnCtrlC?: boolean
/** * Patch console methods to ensure console output doesn't mix with Ink output. * * @default true */ patchConsole?: boolean
/** * Called after each frame render with timing and flicker information. */ onFrame?: (event: FrameEvent) => void}
export type Instance = { /** * Replace previous root node with a new one or update props of the current root node. */ rerender: Ink['render'] /** * Manually unmount the whole Ink app. */ unmount: Ink['unmount'] /** * Returns a promise, which resolves when app is unmounted. */ waitUntilExit: Ink['waitUntilExit'] cleanup: () => void}
/** * A managed Ink root, similar to react-dom's createRoot API. * Separates instance creation from rendering so the same root * can be reused for multiple sequential screens. */export type Root = { render: (node: ReactNode) => void unmount: () => void waitUntilExit: () => Promise<void>}
/** * Mount a component and render the output. */export const renderSync = ( node: ReactNode, options?: NodeJS.WriteStream | RenderOptions,): Instance => { const opts = getOptions(options) const inkOptions: InkOptions = { stdout: process.stdout, stdin: process.stdin, stderr: process.stderr, exitOnCtrlC: true, patchConsole: true, ...opts, }
const instance: Ink = getInstance( inkOptions.stdout, () => new Ink(inkOptions), )
instance.render(node)
return { rerender: instance.render, unmount() { instance.unmount() }, waitUntilExit: instance.waitUntilExit, cleanup: () => instances.delete(inkOptions.stdout), }}
const wrappedRender = async ( node: ReactNode, options?: NodeJS.WriteStream | RenderOptions,): Promise<Instance> => { // Preserve the microtask boundary that `await loadYoga()` used to provide. // Without it, the first render fires synchronously before async startup work // (e.g. useReplBridge notification state) settles, and the subsequent Static // write overwrites scrollback instead of appending below the logo. await Promise.resolve() const instance = renderSync(node, options) logForDebugging( `[render] first ink render: ${Math.round(process.uptime() * 1000)}ms since process start`, ) return instance}
export default wrappedRender
/** * Create an Ink root without rendering anything yet. * Like react-dom's createRoot — call root.render() to mount a tree. */export async function createRoot({ stdout = process.stdout, stdin = process.stdin, stderr = process.stderr, exitOnCtrlC = true, patchConsole = true, onFrame,}: RenderOptions = {}): Promise<Root> { // See wrappedRender — preserve microtask boundary from the old WASM await. await Promise.resolve() const instance = new Ink({ stdout, stdin, stderr, exitOnCtrlC, patchConsole, onFrame, })
// Register in the instances map so that code that looks up the Ink // instance by stdout (e.g. external editor pause/resume) can find it. instances.set(stdout, instance)
return { render: node => instance.render(node), unmount: () => instance.unmount(), waitUntilExit: () => instance.waitUntilExit(), }}
const getOptions = ( stdout: NodeJS.WriteStream | RenderOptions | undefined = {},): RenderOptions => { if (stdout instanceof Stream) { return { stdout, stdin: process.stdin, } }
return stdout}
const getInstance = ( stdout: NodeJS.WriteStream, createInstance: () => Ink,): Ink => { let instance = instances.get(stdout)
if (!instance) { instance = createInstance() instances.set(stdout, instance) }
return instance}