ink

What is ink?

Ink is a React-based framework for building command-line interface (CLI) applications. It allows developers to use React components to create interactive and dynamic CLI tools.

What are ink's main functionalities?

Rendering Text

Ink allows you to render text in the terminal using React components. The example demonstrates a simple 'Hello, world!' text rendering.

const { render, Text } = require('ink');

const App = () => <Text>Hello, world!</Text>;

render(<App />);

Handling User Input

Ink provides hooks like `useInput` to handle user input. This example shows how to exit the application when the user presses 'q'.

const { render, Text, useInput } = require('ink');

const App = () => {
  useInput((input, key) => {
    if (input === 'q') {
      process.exit();
    }
  });

  return <Text>Press 'q' to exit.</Text>;
};

render(<App />);

Using Components

Ink supports layout components like `Box` to arrange other components. This example demonstrates a vertical layout with two text components.

const { render, Box, Text } = require('ink');

const App = () => (
  <Box flexDirection="column">
    <Text>Hello</Text>
    <Text>World</Text>
  </Box>
);

render(<App />);

Styling Text

Ink allows you to style text using properties like `color`. This example shows how to render green-colored text.

const { render, Text } = require('ink');

const App = () => (
  <Text color="green">This is green text</Text>
);

render(<App />);

Other packages similar to ink

blessed

Blessed is a library for creating interactive command-line applications. It provides a wide range of widgets and supports mouse and keyboard input. Compared to Ink, Blessed is more low-level and imperative, whereas Ink leverages React's declarative approach.

ink-select-input

Ink-select-input is a component for Ink that allows you to create interactive select inputs. It is specifically designed to work with Ink, providing a higher-level abstraction for creating selection menus. Unlike Ink, which is a full framework, ink-select-input is a specialized component.

vorpal

Vorpal is a framework for building interactive CLI applications. It provides a command-line interface with built-in help, tab completion, and more. Vorpal is more focused on creating command-based interfaces, whereas Ink is more flexible and component-based.

README

React for CLIs. Build and test your CLI output using components.

Install

$ npm install ink react

Usage

import React, {Component} from 'react';
import {render, Color} from 'ink';

class Counter extends Component {
	constructor() {
		super();

		this.state = {
			i: 0
		};
	}

	render() {
		return (
			<Color green>
				{this.state.i} tests passed
			</Color>
		);
	}

	componentDidMount() {
		this.timer = setInterval(() => {
			this.setState({
				i: this.state.i + 1
			});
		}, 100);
	}

	componentWillUnmount() {
		clearInterval(this.timer);
	}
}

render(<Counter/>);

You can also check it out live on repl.it sandbox. Feel free to play around with the code and fork this repl at https://repl.it/@vadimdemedes/ink-counter-demo.

Built with Ink

• emoj - Find relevant emoji on the command-line.
• emma - Terminal assistant to find and install npm packages.
• swiff - Multi-environment command line tools for time-saving web developers.
• changelog-view - Tool view changelog in console.

Contents

• Getting Started
• Examples
• API
• Building Layouts
• Built-in Components
• Useful Components
• Testing

Getting Started

Ink's goal is to provide the same component-based UI building experience that React provides, but for command-line apps. It uses yoga-layout to allow Flexbox layouts in the terminal. If you are already familiar with React, you already know Ink.

The key difference you have to remember is that the rendering result isn't a DOM, but a string, which Ink writes to the output.

To ensure all examples work and you can begin your adventure with Ink, make sure to set up Babel with a React preset. After installing Babel, configure it in package.json:

{
	"babel": {
		"presets": [
			"@babel/preset-react"
		]
	}
}

Don't forget to import React into every file that contains JSX:

import React from 'react';
import {render, Box} from 'ink';

const Demo = () => (
	<Box>
		Hello World
	</Box>
);

render(<Demo/>);

Examples

• Jest - Implementation of basic Jest UI (live demo).
• Counter - Simple counter that increments every 100ms (live demo).

API

Since Ink is a React renderer, it means that all features of React are supported. Head over to React website for documentation on how to use it. In this readme only Ink's methods will be documented.

render(tree, options)

Returns: Instance

Mount a component and render the output.

tree

Type: ReactElement

options

Type: Object

stdout

Type: stream.Writable
Default: process.stdout

Output stream where app will be rendered.

stdin

Type: stream.Readable
Default: process.stdin

Input stream where app will listen for input.

exitOnCtrlC

Type: boolean
Default: true

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.

debug

Type: boolean
Default: false

If true, each update will be rendered as a separate output, without replacing the previous one.

import React, {Component} from 'react';
import {render, Box} from 'ink';

class Counter extends Component {
	constructor() {
		super();

		this.state = {
			i: 0
		};
	}

	render() {
		return (
			<Box>
				Iteration #{this.state.i}
			</Box>
		);
	}

	componentDidMount() {
		this.timer = setInterval(() => {
			this.setState(prevState => ({
				i: prevState.i + 1
			}));
		}, 100);
	}

	componentWillUnmount() {
		clearInterval(this.timer);
	}
}

const app = render(<Counter/>);

setTimeout(() => {
	// Enough counting
	app.unmount();
}, 1000);

There's also a shortcut to avoid passing options object:

render(<Counter>, process.stdout);

Instance

This is the object that render() returns.

rerender

Replace previous root node with a new one or update props of the current root node.

// Update props of the root node
const {rerender} = render(<Counter count={1}/>);
rerender(<Counter count={2}/>);

// Replace root node
const {rerender} = render(<OldCounter/>);
rerender(<NewCounter/>);

unmount

Manually unmount the whole Ink app.

const {unmount} = render(<MyApp/>);
unmount();

waitUntilExit

Returns a promise, which resolves when app is unmounted.

const {unmount, waitUntilExit} = render(<MyApp/>);

setTimeout(unmount, 1000);

await waitUntilExit(); // resolves after `unmount()` is called

Building Layouts

Ink uses Yoga - a Flexbox layout engine to build great user interfaces for your CLIs. It's important to remember that each element is a Flexbox container. Think of it as if each <div> in the browser had display: flex. See <Box> built-in component below for documentation on how to use Flexbox layouts in Ink.

Built-in Components

<Box>

<Box> it's an essential Ink component to build your layout. It's like a <div style="display: flex"> in a browser.

Import:

import {Box} from 'ink';

Padding

paddingTop

Type: number
Default: 0

paddingBottom

Type: number
Default: 0

paddingLeft

Type: number
Default: 0

paddingRight

Type: number
Default: 0

paddingX

Type: number
Default: 0

paddingY

Type: number
Default: 0

padding

Type: number
Default: 0

<Box paddingTop={2}>Top</Box>
<Box paddingBottom={2}>Bottom</Box>
<Box paddingLeft={2}>Left</Box>
<Box paddingRight={2}>Right</Box>
<Box paddingX={2}>Left and right</Box>
<Box paddingY={2}>Top and bottom</Box>
<Box padding={2}>Top, bottom, left and right</Box>

Margin

marginTop

Type: number
Default: 0

marginBottom

Type: number
Default: 0

marginLeft

Type: number
Default: 0

marginRight

Type: number
Default: 0

marginX

Type: number
Default: 0

marginY

Type: number
Default: 0

margin

Type: number
Default: 0

<Box marginTop={2}>Top</Box>
<Box marginBottom={2}>Bottom</Box>
<Box marginLeft={2}>Left</Box>
<Box marginRight={2}>Right</Box>
<Box marginX={2}>Left and right</Box>
<Box marginY={2}>Top and bottom</Box>
<Box margin={2}>Top, bottom, left and right</Box>

Flex

flexGrow

Type: number
Default: 0

See flex-grow.

<Box>
	Label:
	<Box flexGrow={1}>
		Fills all remaining space
	</Box>
</Box>

flexShrink

Type: number
Default: 1

See flex-shrink.

<Box width={20}>
	<Box flexShrink={2} width={10}>
		Will be 1/4
	</Box>
	<Box width={10}>
		Will be 3/4
	</Box>
</Box>

flexDirection

Type: string
Allowed values: row, row-reverse, column and column-reverse

See flex-direction.

<Box>
	<Box marginRight={1}>X</Box>
	<Box>Y</Box>
</Box>
// X Y

<Box flexDirection="row-reverse">
	<Box>X</Box>
	<Box marginRight={1}>Y</Box>
</Box>
// Y X

<Box flexDirection="column">
	<Box>X</Box>
	<Box>Y</Box>
</Box>
// X
// Y

<Box flexDirection="column-reverse">
	<Box>X</Box>
	<Box>Y</Box>
</Box>
// Y
// X

alignItems

Type: string
Allowed values: flex-start, center and flex-end

See align-items.

<Box alignItems="flex-start">
	<Box marginRight={1}>X</Box>
	<Box>{`A\nB\nC`}</Box>
</Box>
// X A
//   B
//   C

<Box alignItems="center">
	<Box marginRight={1}>X</Box>
	<Box>{`A\nB\nC`}</Box>
</Box>
//   A
// X B
//   C

<Box alignItems="flex-end">
	<Box marginRight={1}>X</Box>
	<Box>{`A\nB\nC`}</Box>
</Box>
//   A
//   B
// X C

justifyContent

Type: string
Allowed values: flex-start, center, flex-end, space-between and space-around.

See justify-content.

<Box justifyContent="flex-start">
	<Box>X</Box>
</Box>
// [X      ]

<Box justifyContent="center">
	<Box>X</Box>
</Box>
// [   X   ]

<Box justifyContent="flex-end">
	<Box>X</Box>
</Box>
// [      X]

<Box justifyContent="space-between">
	<Box>X</Box>
	<Box>Y</Box>
</Box>
// [X      Y]

<Box justifyContent="space-around">
	<Box>X</Box>
	<Box>Y</Box>
</Box>
// [  X   Y  ]

<Color>

The <Color> component is a simple wrapper around the chalk API. It supports all of the chalk's methods as props.

Import:

import {Color} from 'ink';

Usage:

<Color rgb={[255, 255, 255]} bgKeyword="magenta">
	Hello!
</Color>

<Color hex="#000000" bgHex="#FFFFFF">
	Hey there
</Color>

<Color blue>
	I'm blue
</Color>

<Text>

This component can change the style of the text, make it bold, underline, italic or strikethrough.

Import:

import {Text} from 'ink';

bold

Type: boolean
Default: false

italic

Type: boolean
Default: false

underline

Type: boolean
Default: false

strikethrough

Type: boolean
Default: false

Usage:

<Text bold>I am bold</Text>
<Text italic>I am italic</Text>
<Text underline>I am underline</Text>
<Text strikethrough>I am strikethrough</Text>

<Static>

<Static> component allows permanently rendering output to stdout and preserving it across renders. Components passed to <Static> as children will be written to stdout only once and will never be rerendered. <Static> output comes first, before any other output from your components, no matter where it is in the tree. In order for this mechanism to work properly, at most one <Static> component must be present in your node tree and components that were rendered must never update their output. Ink will detect new children appended to <Static> and render them to stdout.

Note: <Static> accepts only an array of children and each of them must have a unique key.

Example use case for this component is Jest's output:

Jest continuously writes the list of completed tests to the output, while updating test results at the bottom of the output in real-time. Here's how this user interface could be implemented with Ink:

<>
	<Static>
		{tests.map(test => (
			<Test key={test.id} title={test.title}/>
		))}
	</Static>

	<Box marginTop={1}>
		<TestResults passed={results.passed} failed={results.failed}/>
	</Box>
</>

See examples/jest for a basic implementation of Jest's UI.

<AppContext>

<AppContext> is a React context, which exposes a method to manually exit the app (unmount).

Import:

import {AppContext} from 'ink';

exit

Type: Function

Exit (unmount) the whole Ink app.

Usage:

<AppContext.Consumer>
	{({ exit }) => (
		{/* Calling `onExit()` from within <MyApp> will unmount the app */}
		<MyApp onExit={exit}/>
	)}
</AppContext.Consumer>

<StdinContext>

<StdinContext> is a React context, which exposes input stream.

Import:

import {StdinContext} from 'ink';

stdin

Type: stream.Readable
Default: process.stdin

Stdin stream passed to render() in options.stdin or process.stdin by default. Useful if your app needs to handle user input.

Usage:

<StdinContext.Consumer>
	{({ stdin }) => (
		<MyComponent stdin={stdin}/>
	)}
</StdinContext.Consumer>

setRawMode

Type: function

See setRawMode. Ink exposes this function via own <StdinContext> to be able to handle Ctrl+C, that's why you should use Ink's setRawMode instead of process.stdin.setRawMode. Ink also enables keypress events via readline.emitKeypressEvents() when raw mode is enabled.

Usage:

<StdinContext.Consumer>
	{({ setRawMode }) => (
		<MyComponent setRawMode={setRawMode}/>
	)}
</StdinContext.Consumer>

<StdoutContext>

<StdoutContext> is a React context, which exposes stdout stream, where Ink renders your app.

Import:

import {StdoutContext} from 'ink';

stdout

Type: stream.Writable
Default: process.stdout

Usage:

<StdoutContext.Consumer>
	{({ stdout }) => (
		<MyComponent stdout={stdout}/>
	)}
</StdoutContext.Consumer>

Useful Components

• ink-text-input - Text input.
• ink-spinner - Spinner.
• ink-select-input - Select (dropdown) input.
• ink-link - Link component.
• ink-box - Styled box component.
• ink-gradient - Gradient color component.
• ink-big-text - Awesome text component.
• ink-image - Display images inside the terminal.
• ink-tab - Tab component.
• ink-color-pipe - Create color text with simpler style strings in Ink.

Incompatible components

These are components that haven't migrated to Ink 2 yet:

• ink-progress-bar - Configurable component for rendering progress bars.
• ink-console - Render output from console[method] calls in a scrollable panel.
• ink-confirm-input - Yes/No confirmation input.
• ink-checkbox-list - Checkbox.
• ink-quicksearch - Select Component with fast quicksearch-like navigation
• ink-autocomplete - Autocomplete.
• ink-table - Table component.
• ink-broadcast - Implementation of react-broadcast for Ink.
• ink-router - Implementation of react-router for Ink.
• ink-select - Select component.
• ink-scrollbar - Scrollbar component.
• ink-text-animation - Text animation component.
• ink-figlet - Large text component with Figlet fonts.
• ink-divider - A divider component.

Testing

Ink components are simple to test with ink-testing-library. Here's a simple example that checks how component is rendered:

import React from 'react';
import {Text} from 'ink';
import {render} from 'ink-testing-library';

const Test = () => <Text>Hello World</Text>;
const {lastFrame} = render(<Test/>);

lastFrame() === 'Hello World'; //=> true

Visit ink-testing-library for more examples and full documentation.

Maintainers

• Vadim Demedes
• Sindre Sorhus

License

MIT