Build a Dialog Manager With State Machines and XState in JavaScript | by Maya Shavin | Jun, 2022

A dialog supervisor with XState

We use dialogs to tell customers about particular and essential info which can require them to carry out extra actions or duties. Most software dialogs are dynamic, and we often can’t afford so as to add all of the dialogs to the principle root factor because the placeholders. Therefore, we want a system to handle, render the suitable content material for a single dialog occasion throughout run time, and set off the open/shut and associated actions accordingly.

To perform that objective, we use state machines and state diagrams.

A state machine, or finite state machine, comprises a finite quantity of states representing the machine’s reactions to a collection of occasions at a given time. A state machine can solely retailer a single standing at a time and may transfer from one state to a different state primarily based on the given occasion inputs.

We use state diagrams to exhibit the movement of a state machine, with every node representing a state and every edge representing the occasion transition from one state to a different. Additionally, for every occasion edge, we are able to execute actions to manage the inner information context of the machine upon state adjustments.

Under is an instance of a toggle state machine with two state nodes (on/off), one linked to a different utilizing the TOGGLE occasion.

Subsequent, let’s outline our dialog state diagram movement.

The character of dialog is to be seen and in focus from the second the consumer opens it till he dismisses it or completes a required motion on the dialog.

Therefore, a dialog machine has two main states: closed and open. closed represents when the dialog shouldn’t be seen to the consumer, and open is in any other case. We transfer from closed to open utilizing the OPEN occasion and from open to closed utilizing the DONE occasion, as proven within the diagram under:

Observe that this movement diagram solely works for easy dialog, the place the consumer doesn’t must carry out any extra motion in addition to opening/closing the dialog.

Within the state of affairs the place the consumer has to carry out a affirmation, the dialog will set off an extra motion, often, a customized motion connected to the dialog, earlier than dismissing the dialog.

Inside its open state, it has to transit internally from being idled (ready for the consumer to hit the affirm button) to executing mode (triggering the customized motion upon affirmation). After ending the customized motion execution, it strikes to the closed state. On this case, we cut up our open standing into two inner states: idle and executing, as within the following diagram:

Certainly, we are able to transition to idle from the executing state and vice versa. And we transit from our main state – open to closed via the open‘s nested state – executing. Thus our diagram comprises the next state nodes:

And we join every state node via the next occasions (edges):

  • OPEN – (closed, open.idle)
  • EXECUTING – (open.idle, open.executing)
  • DISMISS – (open.idle, closed)
  • RETRY – (open.executing, open.idle)
  • DONE – (open.executing, closed)

We title every occasion in capital letters, representing the movement between the supply state and the vacation spot state node. We are able to now exhibit our state machine diagram as under:

For every occasion transition, we need to set off some extra actions to manage the dialog’s information context, reminiscent of:

  • Initialize the context information when opening the dialog primarily based on the inputs.
  • Resetting the information context upon dismissing or closing the dialog.
  • Invoking the customized motion upon dialog affirmation (when in executing state).
  • Assign an error message to the context for displaying an error in invoking the affirmation.

Our dialog state machine diagram now turns into:

We are able to see now how the dialog mechanism ought to look by destructuring our dialog necessities right into a consultant graph.

The following step is to place this diagram into code with the assistance of the XState library.

XState is a JavaScript state administration library utilizing state machines and state charts.

However let’s not confuse it with VueX, Redux, or different normal state administration libraries.

For my part, XState is an express UI state administration library, which means it helps handle the state movement between totally different UI controls whereas additionally performing the information controls on the facet.

You’ll be able to set up XState in your challenge utilizing the next command:

npm i xstate#ORyarn add xstate

As soon as put in, you’ll be able to create a state machine utilizing createMachine from xstate package deal and move the specified machine configurations as the strategy’s enter arguments.

import  createMachine  from 'xstate'export const dialogMachine = createMachine(
/* configurations */

There are a whole lot of fields for configuration APIs accepted by XState library. On this article, we’ll solely take the next major configurations to arrange our machine:

  • id – the distinctive identifier for the state machine.
  • preliminary – the machine’s required beginning state (the entry level).
  • context – the inner information of the machine. We use this subject to retailer our customized motion handlers and customized dialog’ choices reminiscent of title, dataToSubmit, and so on.
  • states – the thing comprises the definitions of all of the attainable states of the machine. We denote every state by a [key, value] pair, the place the key is the state’s title, and the worth is the state’s configuration object.

Under is the instance construction of our dialog machine:

Let’s arrange every State object beneath states. From our earlier diagram, we outline the 2 main states – closed and open and outline the preliminary state as closed:

For the state open, we may even outline its nested states idle and executing through the use of the thing property states, in the identical strategy:

However since open has its inner states, we have to decide its default state (preliminary state). This step is essential for the machine to set its standing appropriately after transitioning to the open state. Because the dialog is open with none affirmation motion carried out by customers, we set the preliminary state to be idle.

Now, let’s add some occasions to our states.

Every state object comprises property on, which represents the thing of occasions accepted to set off transitioning from that state to others.

Every occasion object in XState has a property subject goal representing the id of the vacation spot state to transition. For the closed state, the goal for the OPEN occasion is the open state. This occasion permits the transition for the dialog from being closed to open.

Since we set the default inner state of open to be idle, the transition from closed to open will robotically set the state machine to open.idle standing.

The next occasions we have to create are EXECUTING when the consumer submits (or confirms) the dialog and DISMISS when the consumer chooses to shut the dialog with out performing any motion.

Observe that we have to add # to point the parent-level state closed within the goal state for the DISMISS occasion. With out it, XState will determine the goal state as one of many inner states of open.

Equally, for the executing state, we add the 2 following occasions:

  • RETRY, which can transfer the machine standing again to the idle state if there may be an error executing the dialog motion
  • DONE to shut the dialog when the motion execution completes efficiently.

Up to now, so good? Now we have simply arrange the essential configurations for our machine. The entire working code is as under:

To visualise our state machine and confirm the movement, the XState crew (or Stately crew) developed a terrific Visualizer tool. The software means that you can dwell coding your state machine, debug it visually and see how the transition movement works.

Under is how we are able to take a look at the movement of our newly created dialog-machine machine with this software.

This software means that you can view the present state and the occasion it triggers everytime you transfer from one state to a different utilizing the State tab and Occasions tab, situated on the right-side pane. This visualizer proves to be very helpful in visualizing the state machine movement and verifying our machine logic at an early stage.

Subsequent, we have to add actions to manage the machine’s information context for every occasion transition.

As mentioned to start with, we need to carry out the next information management actions for our dialog machine:

  • Initialize the context information when opening the dialog primarily based on the inputs.
  • Resetting the information context upon dismissing or closing the dialog.
  • Invoking the customized motion upon dialog affirmation (within the executing state).
  • Assign an error message to the context for displaying upon an error in invoking the affirmation.

Let’s work on every motion requirement.

When opening, our dialog element ought to show the content material dynamically in its template, in addition to the title header and the footer actions, as proven within the determine under:

It additionally consists of binding to the proper exterior motion execution at any time when the consumer confirms the dialog. Therefore the dialog machine ought to obtain and preserve some important information in its context, reminiscent of the next:

  • A element occasion to render the content material contained in the dialog. The dialog renders a default “Dialog machine” textual content if no element is accessible.
  • Title of the dialog
  • Dialog button labels (affirm/submit, cancel)
  • Executor for triggering upon consumer confirming the dialog.
  • Exterior information to move to the executor if wanted.
  • Error to show within the dialog if wanted.

We preserve this information object inside the state machine as its context. To replace the context of the state machine, we use the assign API technique from the xstate package deal and the state occasion’s property subject actions.

assign receives an object which defines how the machine ought to replace every subject of the present context. Every subject is a perform that accepts two parameters as under and returns the suitable worth to assign for that context subject:

  • The present context
  • The present occasion triggered

For our OPEN occasion, we replace the context primarily based on the information handed with the occasion object, as proven under:

Subsequent, as we beforehand outlined in our state machine movement, we need to clear up all of the saved information context at any time when the consumer closes the dialog (via DISMISS or DONE).

Since we’re performing the identical motion for each occasions, we are able to create a generic motion clear, as follows:

const clear = assign(
dataToSubmit: (_, occasion) => undefined,
error: (_, occasion) => '',
Part: (_, occasion) => undefined,
executor: (_, occasion) => undefined,

Then move it to the actions subject of each occasions as a part of an array, as proven under:

Because it signifies an error on the RETRY occasion, we need to replace the context.error subject whereas transferring again to the idle state. We proceed utilizing assign to arrange our context.error accordingly:

Additionally, we need to replace dataToSubmit with out transition between states. This replace is crucial in a state of affairs the place we need to set off a customized motion reminiscent of a kind submission for the dialog’s content material element. To realize this objective, we create a brand new occasion UPDATE_DATA for the idle state, with a single motion, as follows:

Now we have accomplished setting the required actions for opening and shutting the dialog, assigning the error when wanted, and updating the saved information for passing to the customized motion.

Now we’ll have a look at our executing state, the place we should invoke our customized executor.

In XState, we use actions to carry out context updating. We are able to additionally use it to invoke a customized motion. Nonetheless, if the customized motion is asynchronous, and there’s a must transit to totally different states relying on that motion execution standing, now we have to create a devoted state to deal with that. In our dialog machine, executing is such a state.

XState gives an invoke property object subject for the state’s configuration object to invoke extra logic in a state. As soon as the dialog is within the executing state, it must set off the customized executor with dataToSubmit, if any, instantly. Upon the execution standing, it can redirect the machine again to an idle state (if error) or closed (if the execution is profitable).

Under is an instance construction of the invoke subject that we use for our dialog machine:

src: 'executeAction', //the supply for the invoking service, is usually a string or perform
id: 'execute-dialog', //required identifier for the invoke logic supply
onDone: , //transition occasion object when service motion's returned promise resolves
onError: //transition occasion object when motion returned promise rejects

src is the place we outline the logic for invoking. It may be a string indicating the title of the service motion handed to the machine throughout its creation or a perform technique that receives context and occasion as its arguments and returns a Promise.

Let’s outline executeAction as under:

const executeAction = async (context, occasion) =>   const  dataToSubmit  = context;  return context.executor?.(dataToSubmit);

Then bind it to the src subject:

src: executeAction,
id: 'execute-dialog',
onDone: , //transition occasion object when service motion's returned promise resolves
onError: //transition occasion object when motion returned promise rejects

A major advantage of utilizing invoke is that it robotically gives binding to onDone and onError for asynchronous capabilities. As soon as the perform resolves, the machine will set off the onDone transition. In any other case, it begins onError accordingly.

Beforehand, we outlined our DONE and RETRY occasions for the executing state. With invoke, we are able to transfer the content material inside DONE to onDone, and from RETRY to onError respectively, and take away the on subject fully. The code for executing state now turns into:

Under is the entire working code for our dialog machine:

At this level, our dialog machine is prepared to be used. Nonetheless, since some actions reminiscent of clear and executeAction are outlined domestically, we can’t be capable to lengthen the machine and customise these actions for future use with out straight making adjustments to the unique machine.

Fortunately, createMachine accepts the second parameter, which is an object that comprises extra choices reminiscent of normal providers (for invoking providers), guards, and actions (for occasion information actions) to make use of within the machine.

Let’s transfer our clear and executeAction to their respective location on this object, as proven under:

And in our machine states, we are able to change the direct perform binding by passing the names clear and executeAction, and XState will deal with the remainder of the binding:

That’s it. Under is the ultimate working code:

And if you’re utilizing TypeScript, under is the information interface instance for the dialog machine’s context:

export interface DialogMachineContext 
Part?: Part

The complete dialog diagram generated by the Visualizer software is as under:

Our dialog machine is now full and extendable. We are able to transfer ahead to make use of it in a Dialog Supervisor element, both in React with @xstate/react, or in Vue with @xstate/vue hooks.

Working with a state machine is enjoyable and difficult on the similar time. It requires a little bit of a studying curve and fairly a change in the way you often proceed in engaged on a brand new function/element.

To construct a correct state machine, you have to outline and plan forward of your element/function movement, module it in components, after which code. I discover it very useful in organizing my code and making a state system for managing my UI elements, such because the dialogs.

Now that we all know create a dialog supervisor machine with XState, let’s make our reusable and generic dialog element in Vue or React, along with the dialog factor, we could?

Initially revealed at

Wish to Join?In the event you’d wish to meet up with me generally, comply with me on Twitter.

More Posts