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

This is a temporary fork of ink#next

Install

$ npm install @terrastack/ink

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/>);

Useful Components

They probably don't work with ink#next out of the box

• ink-redux - Redux bindings.
• ink-text-input - Text input.
• ink-password-input - Password input.
• ink-progress-bar - Configurable component for rendering progress bars.
• ink-spinner - Spinner.
• ink-console - Render output from console[method] calls in a scrollable panel.
• ink-image - Display images inside the terminal.
• ink-confirm-input - Yes/No confirmation input.
• ink-checkbox-list - Checkbox.
• ink-select-input - Select (dropdown) input.
• 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-tab - Tab component.
• ink-link - Link component.
• ink-select - Select component.
• ink-scrollbar - Scrollbar component.
• ink-box - Box component.
• ink-text-animation - Text animation component.
• ink-gradient - Gradient color component.
• ink-big-text - Awesome text component.
• ink-divider - A divider component.

Built with Ink

• emoj - Find relevant emoji on the command-line.
• emma - Terminal assistant to find and install npm packages.

Guide

• Getting Started
• API
• Building Layouts
• Built-in Components

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.

Getting Started

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 {Box} from 'ink';

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

To get started, quickly scaffold out a project using Ink CLI Yeoman generator. To create a new component that you intend to publish, you can use Ink Component generator.

API

Since Ink is a React renderer, it means that all of React is 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)

Mount a component and render the output.

tree

Type: ReactElement

options

stdout

Type: Stream Default: process.stdout

Output stream where app will be rendered.

stdin

Type: Stream Default: process.stdin

Input stream where app will listen for input.

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 unmount = render(<Counter/>);

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

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

render(<Counter>, process.stdout);

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> 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

See flex-grow.

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

flexShrink

Type: number

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> compoment 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.

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

Jest continuosuly 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:

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

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

<StdinContext>

<StdinContext> is a React context, which exposes several props.

Import:

import {StdinContext} from 'ink';

stdin

Type: Stream 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.

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 Default: process.stdout

Usage:

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

License

MIT © Vadim Demedes