mixin to declare state transition methods like start & stop
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}');
- TRANSITION
- TRANSITION_PROMISE
- Action
- Transition
- prepareActions
- StateTransitionMixin
- clazz
- rejectUnlessResolvedWithin
- defineActionMethods
ongoing transition
promise of the ongoing transition
Type: Object
Type: Object
timeout
number in milliseconds the transtion is allowed to takename
stringinitial
Transition to begin withduring
Transition while we are trying to reach the targettarget
Transitionrejected
Transition when soemthing goes wrong
Compile actions and states
as
Object
prepareActions({
start:{
stopped: {
target: 'running',
during: 'starting'
}},
stop: {
running: {
target: 'stopped',
during: 'stopping'
}}});
Returns Array
Extends a class to support state transtions.
Generated mixin class with support of state transtions.
Rejects promise when it is not resolved within given timeout.
Returns Promise
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.
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.
-
object
Object target object where we define the methods -
actionsAndStates
Object object describing the state transitionsactionsAndStates.0
actionsAndStates.1
Returns void
With npm do:
npm install statetransition-mixin
BSD-2-Clause