React for CLIs. Build and test your CLI output using components.
$ npm install ink react
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.
- 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.
- gomoku-terminal - Play online Gomoku in the terminal.
- cfpush - An interactive Cloud Foundry tutorial in your terminal.
- startd - Turn your React component into a web app from the command-line.
- sindresorhus - The Sindre Sorhus CLI.
- tap - A Test-Anything-Protocol library for JavaScript.
- gatsby-cli - Gatsby is a modern web framework for blazing fast websites.
- Getting Started
- Examples
- API
- Building Layouts
- Built-in Components
- Hooks
- Useful Components
- Testing
- Experimental mode
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 get started with Ink quickly, use create-ink-app to quickly scaffold a new Ink-based CLI. Alternatively, here's how to configure Babel to work with Ink. To ensure all examples work and you can begin your adventure, make sure to set up Babel with a React preset. After installing Babel, configure it in package.json
:
{
"babel": {
"presets": [
"@babel/preset-react",
[
"@babel/preset-env",
{
"targets": {
"node": true
}
}
]
]
}
}
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/>);
- Jest - Implementation of basic Jest UI (live demo).
- Counter - Simple counter that increments every 100ms (live demo).
- Form with Validation - Using framework agnostic form library, 🏁 Final Form to manage input state.
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.
Returns: Instance
Mount a component and render the output.
Type: ReactElement
Type: Object
Type: stream.Writable
Default: process.stdout
Output stream where app will be rendered.
Type: stream.Readable
Default: process.stdin
Input stream where app will listen for input.
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.
Type: boolean
Default: false
If true
, each update will be rendered as a separate output, without replacing the previous one.
Type: boolean
Default: false
Enables experimental mode.
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);
This is the object that render()
returns.
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/>);
Manually unmount the whole Ink app.
const {unmount} = render(<MyApp/>);
unmount();
Returns a promise, which resolves when app is unmounted.
const {unmount, waitUntilExit} = render(<MyApp/>);
setTimeout(unmount, 1000);
await waitUntilExit(); // resolves after `unmount()` is called
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.
<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';
Type: number
, string
Width of the element in spaces. You can also set it in percent, which will calculate the width based on the width of parent element.
<Box width={4}>X</Box> //=> 'X '
<Box width={10}>
<Box width="50%">X</Box>
Y
</Box> //=> 'X Y'
Type: number
, string
Height of the element in lines (rows). You can also set it in percent, which will calculate the height based on the height of parent element.
<Box height={4}>X</Box> //=> 'X\n\n\n'
<Box height={6} flexDirection="column">
<Box height="50%">X</Box>
Y
</Box> //=> 'X\n\n\nY\n\n'
Type: number
Sets a minimum width of the element. Percentages aren't supported yet, see facebook/yoga#872.
Type: number
Sets a minimum height of the element. Percentages aren't supported yet, see facebook/yoga#872.
Type: string
Values: wrap
truncate
truncate-start
truncate-middle
truncate-end
This property tells Ink to wrap or truncate text content of <Box>
if its width is larger than container. If wrap
is passed, Ink will wrap text and split it into multiple lines. If truncate-*
is passed, Ink will truncate text instead, which will result in one line of text with the rest cut off.
Note: Ink doesn't wrap text by default.
<Box textWrap="wrap">Hello World</Box>
//=> 'Hello\nWorld'
// `truncate` is an alias to `truncate-end`
<Box textWrap="truncate">Hello World</Box>
//=> 'Hello…'
<Box textWrap="truncate-middle">Hello World</Box>
//=> 'He…ld'
<Box textWrap="truncate-start">Hello World</Box>
//=> '…World'
Type: number
Default: 0
Type: number
Default: 0
Type: number
Default: 0
Type: number
Default: 0
Type: number
Default: 0
Type: number
Default: 0
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>
Type: number
Default: 0
Type: number
Default: 0
Type: number
Default: 0
Type: number
Default: 0
Type: number
Default: 0
Type: number
Default: 0
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>
Type: number
Default: 0
See flex-grow.
<Box>
Label:
<Box flexGrow={1}>
Fills all remaining space
</Box>
</Box>
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>
Type: number
, string
See flex-basis.
<Box width={6}>
<Box flexBasis={3}>X</Box>
Y
</Box> //=> 'X Y'
<Box width={6}>
<Box flexBasis="50%">X</Box>
Y
</Box> //=> 'X Y'
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
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
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 ]
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>
This component can change the style of the text, make it bold, underline, italic or strikethrough.
Import:
import {Text} from 'ink';
Type: boolean
Default: false
Type: boolean
Default: false
Type: boolean
Default: false
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>
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>
is a React context, which exposes a method to manually exit the app (unmount).
Import:
import {AppContext} from 'ink';
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>
If exit
is called with an Error, waitUntilExit
will reject with that error.
<StdinContext>
is a React context, which exposes input stream.
Import:
import {StdinContext} from 'ink';
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>
Type: boolean
A boolean flag determining if the current stdin
supports setRawMode
.
A component using setRawMode
might want to use isRawModeSupported
to nicely fall back in environments where raw mode is not supported.
Usage:
<StdinContext.Consumer>
{({ isRawModeSupported, setRawMode, stdin }) => (
isRawModeSupported ? <MyInputComponent setRawMode={setRawMode} stdin={stdin}/> : <MyComponentThatDoesntUseInput />
)}
</StdinContext.Consumer>
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.
Warning: This function will throw unless the current stdin
supports setRawMode
. Use isRawModeSupported
to detect setRawMode
support.
Usage:
<StdinContext.Consumer>
{({ setRawMode }) => (
<MyComponent setRawMode={setRawMode}/>
)}
</StdinContext.Consumer>
<StdoutContext>
is a React context, which exposes stdout stream, where Ink renders your app.
Import:
import {StdoutContext} from 'ink';
Type: stream.Writable
Default: process.stdout
Usage:
<StdoutContext.Consumer>
{({ stdout }) => (
<MyComponent stdout={stdout}/>
)}
</StdoutContext.Consumer>
This hook is used for handling user input.
It's a more convienient alternative to using StdinContext
and listening to data
events.
The callback you pass to useInput
is called for each character when user enters any input.
However, if user pastes text and it's more than one character, the callback will be called only once and the whole string will be passed as input
.
You can find a full example of using useInput
at examples/useinput.
import {useInput} from 'ink';
const UserInput = () => {
useInput((input, key) => {
if (input === 'q') {
// Exit program
}
if (key.leftArrow) {
// Left arrow key pressed
}
});
return …
};
The handler function that you pass to useInput
receives two arguments:
Type: string
The input that the program received.
Type: object
Handy information about a key that was pressed.
Type: boolean
Default: false
If an arrow key was pressed, the corresponding property will be true
.
For example, if user presses left arrow key, key.leftArrow
equals true
.
Type: boolean
Default: false
Return (Enter) key was pressed.
Type: boolean
Default: false
Ctrl key was pressed.
Type: boolean
Default: false
Shift key was pressed.
Type: boolean
Default: false
Meta key was pressed.
- 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.
- ink-multi-select - Select one or more values from a list
- ink-divider - A divider component.
- ink-progress-bar - Configurable component for rendering progress bars.
- ink-table - Table component.
These are components that haven't migrated to Ink 2 yet:
- 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-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 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.
Ink has experimental mode, which currently enables a more efficient and faster reconciler and renderer.
Instead of shipping it under next
tag or something similar, Ink ships it as part of a regular release.
It can be enabled simply by passing experimental
parameter to render()
function:
render(<App/>, {experimental: true});
Experimental mode actually includes stable features, but I want to be extra sure that it doesn't introduce regressions before shipping this new code for everyone and making it a default.
Feel free to use experimental mode in development and I would appreciate if you reported any regressions you might see.