A tool for managing continuous async process by starting, stopping, restarting and disposing
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.



Set up asynchronous processes that can be started, restarted, stopped and disposed.

This project was created to manage complex rendering logic. It allows you to define several processes that can at any time be started, stopped, restarted or disposed. When you stop a process its current step will finish, but the next step will not execute. Think of it as using a promise which by default executes synchronously and can be stopped, restarted and disposed (can not be started anymore).

Big shoutout to Normatic for open sourcing this tool as a thanks to the open source community for its contributions, allowing Normatic to build great experiences for their customers!

import { Process } from "process-control";

const myProcess = new Process({
  // Automatically dispose when the process reaches its end
  dispose: true
  // Do some work and return a value for the next step
  .then(() => 123)
  // Do some work and return a promise to hold further execution
  .then(() => Promise.resolve())
  // Do work in parallel
  .all([() => Promise.resolve(), otherProcess])
  // Compose in an other process instance
  // Return a function that works like a synchronous promise, meaning that
  // calling resolve() will instantly trigger the next step, not on next
  // tick as native promises do
  .then(() => {
    return (resolve, reject) => {}

  Start the process. If you try to start a running process, it will
  stop the current one, and once stopped start again. Returns
  a promise

  Stop the process. Current started process promise will throw an exception.

  Restart the process. Stops the current process and then starts when it is stopped.

  Disposes the process. Nothing happens when you try to start it.

  The state of the process

NB! Be careful composing one process into multiple other processes. As one process might try to stop the composed process while the other expects it to do its work!