statetransition-mixin

statetransition-mixin

mixin to declare state transition methods like start & stop

usage

import { StateTransitionMixin, prepareActions } = from 'statetransition-mixin';

const actions = prepareActions({
start: { // declare start() and call _start() internally
  stopped: { // can be called within stopped state
    target: "running",
    during: "starting",
    timeout: 10
  }
},
stop: { // declare stop() and call _stop() internally
  running: {. // can be called when running
    target: "stopped",
    during: "stopping",
    timeout: 5
  },
  starting: { // or when starting
    target: "stopped",
    during: "stopping",
    timeout: 10
  }
}
});

class BaseClass {}

class StatefullClass extends StateTransitionMixin(BaseClass, actions, 'stopped') {

  // will be called to go from stopped to running
  async _start() {
    return new Promise(resolve => setTimeout(() => resolve(), 10));
  }
}

let myObject = new StatefullClass();

console.log(myObject.state === 'stopped' ? "is stopped" : "hmm ?")

myObject.start().then( (o) => console.log('started == ${o.state}'));
console.log('starting == ${myObject.state}');

myObject.stop().then( (o) => console.log('stopped == ${o.state}'));
console.log('stopping == ${myObject.state}');

API

Table of Contents

• TRANSITION
• TRANSITION_PROMISE
• Action
  • Properties
• Transition
  • Properties
• prepareActions
  • Parameters
  • Examples
• StateTransitionMixin
  • Parameters
• clazz
• rejectUnlessResolvedWithin
  • Parameters
• defineActionMethods
  • Special handling of consequent transitions
  • Parameters

TRANSITION

ongoing transition

TRANSITION_PROMISE

promise of the ongoing transition

Action

Type: Object

Properties

• name string like 'start' or 'stop'
• transitions Object possible transitions from the current state

Transition

Type: Object

Properties

• timeout number in milliseconds the transtion is allowed to take
• initial Transition to begin with
• during Transition while we are trying to reach the target
• target Transition
• rejected Transition when soemthing goes wrong

prepareActions

Compile actions and states

Parameters

• as Object

Examples

prepareActions({
start:{
 stopped: {
   target: 'running',
   during: 'starting'
}},
stop: {
 running: {
   target: 'stopped',
   during: 'stopping'
 }}});

Returns Array

StateTransitionMixin

Extends a class to support state transtions.

Parameters

• superclass Class
• actions Array<Action>
• initialState string starting state

clazz

Generated mixin class with support of state transtions.

rejectUnlessResolvedWithin

Rejects promise when it is not resolved within given timeout.

Parameters

• promise Promise
• timeout number in miliseconds
• name string

Returns Promise

defineActionMethods

Defines methods to perform the state transitions. States are traversed in the following way:

current -> during -> final

If the step is not in one of the transitions current states and also not already in the transitions final state a rejecting promise will be delivered from the generated function. In the 'during' state a function named '_' + (sample: '_start()') will be called first.

It is expected that this function delivers a promise.

Special handling of consequent transitions

While in a during state the former delivered promise will be delivered again. This enshures that several consequent transitions in a row will be fullfiled by the same promise. There can only be one transition in place at a given point in time.

Parameters

• object Object target object where we define the methods

• actionsAndStates Object object describing the state transitions

  • actionsAndStates.0
  • actionsAndStates.1

Returns void

install

With npm do:

npm install statetransition-mixin

license

BSD-2-Clause