A state machine abstraction for React

React Automata

A state machine abstraction for React that provides declarative state management and automatic test generation.

Quick Start

Installation

react and react-test-renderer are peer dependencies.

yarn add react-automata

Usage

// App.js

import React from 'react'
import { Action, withStateMachine } from 'react-automata'

const statechart = {
  initial: 'a',
  states: {
    a: {
      on: {
        NEXT: 'b',
      },
      onEntry: 'sayHello',
    },
    b: {
      on: {
        NEXT: 'a',
      },
      onEntry: 'sayCiao',
    },
  },
}

class App extends React.Component {
  handleClick = () => {
    this.props.transition('NEXT')
  }

  render() {
    return (
      <div>
        <button onClick={this.handleClick}>NEXT</button>
        <Action is="sayHello">Hello, A</Action>
        <Action is="sayCiao">Ciao, B</Action>
      </div>
    )
  }
}

export default withStateMachine(statechart)(App)
// App.spec.js

import { testStateMachine } from 'react-automata'
import App from './App'

test('it works', () => {
  testStateMachine(App)
})
// App.spec.js.snap

exports[`it works: a 1`] = `
<div>
  <button
    onClick={[Function]}
  >
    NEXT
  </button>
  Hello, A
</div>
`;

exports[`it works: b 1`] = `
<div>
  <button
    onClick={[Function]}
  >
    NEXT
  </button>
  Ciao, B
</div>
`;

API

withStateMachine(statechart[, options])(Component)

The withStateMachine higher-order component accepts an xstate configuration object or an xstate machine, some options and a component.
It returns a new component with special props, action and activity methods and additional lifecycle hooks.
The initial machine state and the initial data can be passed to the resulting component through the initialMachineState and initialData props.

Options

Option Type Description
channel string The key of the context on which to set the state.
devTools bool To connect the state machine to the Redux DevTools Extension.

Props

transition(event[, updater])

The method to change the state of the state machine.
It takes an optional updater function that receives the previous data and returns a data change.
The updater can also be an object, which gets merged into the current data.

handleClick = () => {
  this.props.transition('FETCH')
}

machineState

The current state of the state machine.

It's not recommended to use this value because it couples the component and the state machine.

<button onClick={this.handleClick}>
  {this.props.machineState === 'idle' ? 'Fetch' : 'Retry'}
</button>

Action and Activity methods

All the component's methods whose names match the names of actions and activities, are fired when the related transition happen.
Actions receive the state and the event as arguments. Activities receive a boolean that is true when the activity should start, and false otherwise.

For example:

const statechart = {
  // ...
  fetching: {
    on: {
      SUCCESS: 'success',
      ERROR: 'error',
    },
    onEntry: 'fetchGists',
  },
  // ...
}

class App extends React.Component {
  // ...
  fetchGists() {
    fetch('https://api.github.com/users/gaearon/gists')
      .then(response => response.json())
      .then(gists => this.props.transition('SUCCESS', { gists }))
      .catch(() => this.props.transition('ERROR'))
  }
  // ...
}

Lifecycle hooks

componentWillTransition(event)

The lifecycle method invoked when the transition function has been called.
It provides the event, and can be used to run side-effects.

componentWillTransition(event) {
  if (event === 'FETCH') {
    fetch('https://api.github.com/users/gaearon/gists')
      .then(response => response.json())
      .then(gists => this.props.transition('SUCCESS', { gists }))
      .catch(() => this.props.transition('ERROR'))
  }
}

componentDidTransition(prevMachineState, event)

The lifecycle method invoked when a transition has happened and the state is updated.
It provides the previous state machine, and the event.
The current machineState is available in this.props.

componentDidTransition(prevMachineState, event) {
  Logger.log(event)
}

<Action />

The component to define which parts of the tree should be rendered for a given action (or set of actions).

Prop Type Description
is oneOfType(string, arrayOf(string)) The action(s) for which the children should be shown. It accepts the exact value, a glob expression or an array of values/expressions (e.g. is="fetch", is="show*" or is={['fetch', 'show*']).
channel string The key of the context from where to read the state.
children node The children to be rendered when the conditions match.
render func The render prop receives a bool (true when the conditions match) and it takes precedence over children.
onHide func The function invoked when the component becomes invisible.
onShow func The function invoked when the component becomes visible.
<Action is="showError">Oh, snap!</Action>
<Action
  is="showError"
  render={visible => (visible ? <div>Oh, snap!</div> : null)}
/>

<State />

The component to define which parts of the tree should be rendered for a given state (or set of states).

Prop Type Description
is oneOfType(string, arrayOf(string)) The state(s) for which the children should be shown. It accepts the exact value, a glob expression or an array of values/expressions (e.g. is="idle", is="error.*" or is={['idle', 'error.*']).
channel string The key of the context from where to read the state.
children node The children to be rendered when the conditions match.
render func The render prop receives a bool (true when the conditions match) and it takes precedence over children.
onHide func The function invoked when the component becomes invisible.
onShow func The function invoked when the component becomes visible.
<State is="error">Oh, snap!</State>
<State
  is="error"
  render={visible => (visible ? <div>Oh, snap!</div> : null)}
/>

testStateMachine(Component[, { fixtures, extendedState }])

The method to automagically generate tests given a component wrapped into withStateMachine.
It accepts an additional fixtures option to describe the data to be injected into the component for a given transition, and an extendedState option to control the statechart's conditions - both are optional.

const fixtures = {
  initialData: {
    gists: [],
  },
  fetching: {
    SUCCESS: {
      gists: [
        {
          id: 'ID1',
          description: 'GIST1',
        },
        {
          id: 'ID2',
          description: 'GIST2',
        },
      ],
    },
  },
}

test('it works', () => {
  testStateMachine(App, { fixtures })
})

Examples

GitHub