@peter.naydenov/fsm 2.2.1 → 2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peter.naydenov/fsm",
-  "version": "2.2.1",
+  "version": "2.2.4",
   "description": "Simple Finite State Machine",
   "main": "src/index.js",
   "scripts": {
@@ -10,13 +10,18 @@
   "author": "Peter Naydenov",
   "license": "MIT",
   "dependencies": {
-    "ask-for-promise": "^1.3.1"
+    "@peter.naydenov/walk": "1.1.0",
+    "ask-for-promise": "1.3.1"
   },
   "devDependencies": {
-    "chai": "4.2.0",
+    "chai": "4.3.6",
     "expect.js": "0.3.1",
-    "mocha": "6.1.4",
-    "nyc": "14.1.1"
+    "mocha": "10.0.0",
+    "nyc": "15.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PeterNaydenov/fsm.git"
   },
   "nyc": {
     "include": [

package/src/index.js

@@ -1,23 +1,23 @@
 
 const 
          MISSING_STATE = 'N/A'
-       , askForPromise = require ( 'ask-for-promise' )
+       , askForPromise  = require ( 'ask-for-promise' )
+       , methods        = require ( './methods/index' )
+       , walk           = require ( '@peter.naydenov/walk' )
        ;
 
-class Fsm {
-    constructor ({init, table, stateData, debug }, lib={} ) {
-            const 
-                  fsm   = this
-                , sData = Object.assign ( {}, stateData )
-                ;
+function Fsm ({init, table, stateData, debug }, lib={} ) {
+            const fsm   = this;
+                
             fsm.state            = init || MISSING_STATE
             fsm.initialState     = init || MISSING_STATE
             fsm.lock             = false   // switch 'ON' during transition in progress. Write other updates in cache.
             fsm.cache            = []      // cached 'update' commands
+            fsm.askForPromise    = askForPromise
 
-            fsm.stateData        = sData
-            fsm.initialStateData = sData
-            fsm.dependencies     = {}
+            fsm.stateData        = walk ( stateData ) 
+            fsm.initialStateData = walk ( stateData )
+            fsm.dependencies     = { walk, askForPromise }
             fsm.callback = {
                              update     : []
                            , transition : []
@@ -25,286 +25,18 @@ class Fsm {
                            , negative   : []
                         }
 
-            const result = fsm._setTransitions ( table, lib );
-            if ( debug )   fsm._warn ( result.transitions )
-            fsm.transitions = result.transitions
-            fsm.nextState   = result.nextState
-            fsm.chainActions  = result.chainActions
-        } // constructor func.
+            walk ( methods, (v,k) => fsm[k] = methods[k](fsm)   )   // Attach methods to fsm
 
+            const {transitions, nextState, chainActions } = fsm._setTransitions ( table, lib );
+            if ( debug )   fsm._warn ( transitions )
+            fsm.transitions   = transitions
+            fsm.nextState     = nextState
+            fsm.chainActions  = chainActions
+} // Fsm func.  
 
 
 
 
-     _warn ( data ) {
-     // *** Warn if transition function used in description table is not defined.
-                Object.keys(data).forEach ( k => {
-                        if (data[k] == null)   console.log ( `Warning: Transition for ${k} is not defined` )
-                   })
-        } // _warn func.
-
-
-
-
-
-     _setTransitions ( data, lib ) {   // ( machineTable, transitionLib ) --> {transitions, nextState, chainActions}
-     // *** Converts initial FSM data to useful fsm objects.
-                let 
-                       fsm = this
-                     , transitions = {}
-                     , nextState = {}
-                     , chainActions = {}
-                     ;
-                data.forEach ( el => {
-                        const 
-                              [ from, action, next, transitionName, alt ] = el
-                            , transition = lib [ transitionName ]
-                            , key = `${from}/${action}`
-                            ;
-                        transitions[key] = transition || null
-                        nextState  [key] = next
-                        if ( fsm._isAltValid(alt) ) {  
-                                chainActions [key] = []
-                                chainActions [key][0] = alt[0]
-                                chainActions [key][1] = alt[1]
-                           }
-                   })
-                return { transitions, nextState, chainActions }
-        } // setTransitions
-
-
-
-
-
-     _isAltValid ( alt ) {   //   (altAction) -> boolean
-     // *** Check if alt is valid altAction.
-                if ( !(alt instanceof Array) )   return false
-                if ( alt.length != 2         )   return false
-                alt.forEach ( m => {
-                                if ( m !== false ||  typeof m != 'string' )    return false
-                        })
-                return true
-        } // _isAltValid func.
-
-
-
-
-
-     setDependencies ( deps ) {
-                this.dependencies = Object.assign ( {}, this.dependencies, deps )
-        } // setDependencies func.
-     
-
-
-
-
-     on ( eName, fn) {
-     // *** Register callback functions on: 'update', 'transition', 'negative', 'positive'
-                const 
-                      fsm = this
-                    , cb = fsm.callback;
-                if ( cb[eName] )   cb[eName].push ( fn )
-        } // on func.
-
-
-
-
-     off ( eName ) {
-             if ( !fsm.callback[eName] )   return
-             fsm.callback[eName] = []
-        } // off func.
-
-
-
-
-
-      getState () { return this.state }
-
-
-
-
-
-      importState ( {state, stateData} ) {
-        // *** Import existing state to fsm
-                const fsm = this;
-                if ( state ) {
-                        fsm.state = state
-                        fsm.stateData = Object.assign ( {}, stateData )
-                   }
-        } // importState func.
-
-
-
-
-
-      exportState () {
-        // *** Export internal flags and state as an object
-                const 
-                          fsm       = this
-                        , state     = fsm.state
-                        , stateData = Object.assign  ( {}, fsm.stateData )
-                        ;
-                return {
-                          state
-                        , stateData
-                     }
-        } // exportState func.
-
-
-
-
-
-      transit ( task, key, dt ) {   //   ( promiseObj, transitionKey, additionalData ) -> void
-        // *** Execute transition if exists. Ignore all non-predefined cases
-                const
-                        fsm = this
-                     , dependencies = Object.assign ( {}, fsm.dependencies )
-                     , stateData    = Object.assign ( {}, fsm.stateData )
-                     , transition   = fsm.transitions [ key ]
-                     ;
-                if ( typeof transition === 'function' )   transition ( task, dependencies, stateData, dt )
-                else                                      task.done ({ success : false })   // ignore all non-predefined cases
-        } // transit func.
-           
-           
-           
-
-
-      update ( action, dt ) {   //   () -> Promise<transitionResponse>
-        // *** Executes transition-functions and transition-chains.
-                const 
-                        fsm = this
-                      , theUpdate = askForPromise ()
-                      ;
-                if ( fsm.lock ) {  
-                        fsm.cache.push ( { theUpdate, action, dt })
-                        return theUpdate.promise
-                   }
-                fsm._updateStep ( theUpdate, action, dt )
-                return theUpdate.promise
-        } // update func.
-
-
-
-
-
-     _updateStep ( theUpdate, action, dt ) {
-                const 
-                      fsm = this
-                    , task = askForPromise ()
-                    , key  = `${fsm.state}/${action}`
-                    , cb   = fsm.callback
-                    ;
-                fsm.lock = true
-                fsm.transit ( task, key, dt )
-                task.onComplete (
-                        result => {
-                                /**
-                                 *    Result description:
-                                 *  {
-                                 *       success   - boolean. Is it transition successful.
-                                 *     ? stateData - object. Flat object with fsm state values.
-                                 *     ? response  - object. External data as response of transition if needed.
-                                 *     ? command   - string. Next action if function-chaining.
-                                 *  }
-                                 */
-                                
-                                let 
-                                      chainActions = fsm._getChain ( fsm.chainActions, key)
-                                    , data = result.response
-                                    ;
-                                
-                                if ( result.success ) {
-                                        fsm.state = fsm.nextState [ key ]
-                                        if ( result.stateData )   fsm.stateData = result.stateData
-                                        cb [ 'positive'   ].forEach ( fn => fn ( fsm.state, data)   )
-                                        cb [ 'transition' ].forEach ( fn => fn ( fsm.state, data)   )
-                                        if ( chainActions && chainActions[0] ) {
-                                                fsm._updateStep ( theUpdate, chainActions[0], data )   // Positive altAction index
-                                                return
-                                           }
-                                    }
-                                else {
-                                        cb [ 'negative'   ].forEach ( fn => fn ( fsm.state, data)   )
-                                        cb [ 'transition' ].forEach ( fn => fn ( fsm.state, data)   )
-                                        if ( chainActions && chainActions[1] ) {
-                                                fsm._updateStep ( theUpdate, chainActions[1], data )   // Negative altAction index
-                                                return
-                                           }
-                                     }
-                                if ( result.command ) {
-                                           fsm._updateStep ( theUpdate, result.command, data )
-                                           return
-                                      }
-                                theUpdate.done ( data )
-                        }) // task onComplete
-
-                theUpdate.onComplete ( data => {
-                                const updateCallbacks = askForPromise ( cb['update'] );
-                                cb [ 'update' ].forEach ( (fn,i) => {
-                                                fn ( fsm.state, data )
-                                                updateCallbacks[i].done ()
-                                        })
-                                updateCallbacks.onComplete ( x => {
-                                                fsm.lock = false
-                                                fsm._triggerCacheUpdate ()
-                                        })
-                        })
-                task.promise.catch ( () =>  console.log ( `Failed in step ${key}`)   )
-        }  // updateStep func.
-
-
-
-
-
-       ignoreCachedUpdates () {
-        // *** Ignore all cached updates
-                const 
-                          fsm   = this
-                        , cache = fsm.cache
-                        ;
-                cache.forEach ( ({theUpdate, action, dt} ) =>  theUpdate.cancel ( `Action '${action}' was ignored` ))
-                fsm.cache = []
-          }  // ignoreCache func.
-
-
-
-
-      _triggerCacheUpdate () {
-                const fsm = this;
-                if ( fsm.cache.length !== 0 ) {
-                                        const { theUpdate, action, dt } = fsm.cache [0]
-                                        fsm.cache = fsm.cache.reduce ( (res,el,i) => {
-                                                                if ( i != 0 )   res.push(el)
-                                                                return res
-                                                        },[] )
-                                        fsm._updateStep ( theUpdate, action, dt )
-                        }
-        }  // _triggerCachceUpdate func.
-
-
-
-
-
-     _getChain ( chainActions, key ) {
-                if ( !chainActions[key] )   return false
-                return chainActions [key]
-        }  // getAlt func.
-
-
-
-
-
-     reset () {
-             const fsm = this;
-             fsm.state = fsm.initialState
-             fsm.stateData = fsm.initialStateData
-        } // reset func.
-
-} // class Fsm
-
-
-
 module.exports = Fsm
 
 

package/src/methods/_getChain.js

@@ -0,0 +1,11 @@
+function _getChain () {
+return function ( chainActions, key ) {
+    if ( !chainActions[key] )   return false
+    return chainActions [key]
+}}  // getChain func.
+
+
+
+module.exports = _getChain
+
+

package/src/methods/_onUpdateTask.js

@@ -0,0 +1,23 @@
+function _onUpdateTask ( fsm ) {
+return function _onUpdateTask ( data ) {
+    const 
+           cb = fsm.callback
+        ,  updateCallbacks = fsm.askForPromise ( cb['update'] )
+        ;
+
+    cb [ 'update' ].forEach ( (fn,i) => {
+                    fn ( fsm.state, data )
+                    updateCallbacks[i].done ()
+            })
+
+    updateCallbacks.onComplete ( x => {
+                    fsm.lock = false
+                    fsm._triggerCacheUpdate ()
+            })
+}} // _onUpdateTask func.
+
+
+  
+module.exports = _onUpdateTask
+
+

package/src/methods/_setTransitions.js

@@ -0,0 +1,44 @@
+function _setTransitions () {
+return function ( table, lib ) {   // ( machineTable, transitionLib ) --> {transitions, nextState, chainActions}
+     // *** Converts initial FSM data to useful fsm objects.
+                let 
+                       transitions = {}
+                     , nextState = {}
+                     , chainActions = {}
+                     ;
+                table.forEach ( el => {
+                        const 
+                              [ from, action, next, transitionName, alt ] = el
+                            , transition = lib [ transitionName ]
+                            , key = `${from}/${action}`
+                            ;
+                        transitions[key] = transition || null
+                        nextState  [key] = next
+                        if ( _isAltValid(alt) ) {  
+                                chainActions [key] = []
+                                chainActions [key][0] = alt[0]
+                                chainActions [key][1] = alt[1]
+                           }
+                   })
+                return { transitions, nextState, chainActions }
+ }} // _setTransitions func.
+
+
+
+
+
+function _isAltValid ( alt ) {   //   (altAction) -> boolean
+// *** Check if alt is valid altAction.
+            if ( !(alt instanceof Array) )   return false
+            if ( alt.length != 2         )   return false
+            alt.forEach ( m => {
+                            if ( m !== false ||  typeof m != 'string' )    return false
+                    })
+            return true
+  } // _isAltValid func.
+       
+
+
+module.exports  = _setTransitions        
+
+

package/src/methods/_transit.js

@@ -0,0 +1,18 @@
+function _transit (fsm ) {
+return function ( task, key, dt ) {   //   ( promiseObj, transitionKey, additionalData ) -> void
+// *** Execute transition if exists. Ignore all non-predefined cases
+        const
+                  dependencies = fsm.dependencies
+                , { walk }     = dependencies
+                , stateData    = walk ( fsm.stateData )
+                , transition   = fsm.transitions [ key ]
+                ;
+        if ( typeof transition === 'function' )   transition ( task, dependencies, stateData, dt )
+        else                                      task.done ({ success : false })   // ignore all non-predefined cases
+}} // _transit func.
+
+
+
+module.exports = _transit
+
+

package/src/methods/_triggerCacheUpdate.js

@@ -0,0 +1,19 @@
+function _triggerCacheUpdate ( fsm ) {
+return function () {
+        if ( fsm.cache.length !== 0 ) {
+                const { updateTask, action, dt } = fsm.cache [0]
+                fsm.cache = fsm.cache.reduce ( (res,el,i) => {
+                                        if ( i != 0 )   res.push(el)
+                                        return res
+                                },[] )
+
+                fsm._updateStep ( updateTask, action, dt )
+                updateTask.onComplete ( data => fsm._onUpdateTask ( data )   )
+            }
+}}  // _triggerCacheUpdate func.
+
+
+
+module.exports = _triggerCacheUpdate
+
+

package/src/methods/_updateStep.js

@@ -0,0 +1,59 @@
+function _updateStep ( fsm ) {
+return function ( updateTask, action, dt ) {
+    const 
+          task = fsm.askForPromise ()
+        , key  = `${fsm.state}/${action}`
+        , cb   = fsm.callback
+        ;
+    fsm.lock = true
+    fsm._transit ( task, key, dt )
+    task.onComplete (
+            result => {
+                    /**
+                     *    Result description:
+                     *  {
+                     *       success   - boolean. Is it transition successful.
+                     *     ? stateData - object. Flat object with fsm state values.
+                     *     ? response  - object. External data as response of transition if needed.
+                     *     ? command   - string. Next action if function-chaining. (depricated!) Use a chainAction inside the logic table
+                     *  }
+                     */
+                    
+                    let 
+                          chainActions = fsm._getChain ( fsm.chainActions, key)
+                        , data = result.response
+                        ;
+                
+                    if ( result.success ) {
+                            fsm.state = fsm.nextState [ key ]
+                            if ( result.stateData )   fsm.stateData = result.stateData
+                            cb [ 'positive'   ].forEach ( fn => fn ( fsm.state, data)   )
+                            cb [ 'transition' ].forEach ( fn => fn ( fsm.state, data)   )
+                            if ( chainActions && chainActions[0] ) {
+                                    fsm._updateStep ( updateTask, chainActions[0], data )   // Positive altAction index
+                                    return
+                               }
+                        }
+                    else {
+                            cb [ 'negative'   ].forEach ( fn => fn ( fsm.state, data)   )
+                            cb [ 'transition' ].forEach ( fn => fn ( fsm.state, data)   )
+                            if ( chainActions && chainActions[1] ) {
+                                    fsm._updateStep ( updateTask, chainActions[1], data )   // Negative altAction index
+                                    return
+                               }
+                         }
+                    if ( result.command ) {
+                               fsm._updateStep ( updateTask, result.command, data )
+                               return
+                          }
+                    updateTask.done ( data )
+            }) // task onComplete
+
+    task.promise.catch ( () =>  console.log ( `Failed in step ${key}`)   )
+}}  // updateStep func.
+
+
+
+module.exports = _updateStep
+
+

package/src/methods/_warn.js

@@ -0,0 +1,14 @@
+function _warn ( fsm ) {
+return function ( transitions ) {
+    // *** Warn if transition function used in description table is not defined.
+                const { walk } = fsm.dependencies;
+                walk ( transitions, (v,k) => {
+                            if (v == null)   console.log ( `Warning: Transition for ${k} is not defined` )
+                     })
+}} // warn func.
+
+
+
+module.exports = _warn
+
+

package/src/methods/exportState.js

@@ -0,0 +1,19 @@
+function exportState (fsm) {
+return function () {
+    // *** Export internal flags and state as an object
+            const 
+                  state     = fsm.state
+                ,  { walk } = fsm.dependencies
+                , stateData = walk ( fsm.stateData )
+                ;
+            return {
+                      state
+                    , stateData
+                 }
+}} // exportState func.
+
+
+
+module.exports = exportState
+
+

package/src/methods/getState.js

@@ -0,0 +1,10 @@
+function getState ( fsm ) {
+return function () { 
+        return fsm.state 
+}} // getState func.
+
+
+
+module.exports = getState
+
+

package/src/methods/ignoreCacheUpdates.js

@@ -0,0 +1,13 @@
+function ignoreCachedUpdates ( fsm ) {
+return function () {
+    // *** Ignore all cached updates
+            const cache = fsm.cache;
+            cache.forEach ( ({updateTask, action, dt} ) =>  updateTask.cancel ( `Action '${action}' was ignored` ))
+            fsm.cache = []
+}}  // ignoreCache func.
+
+
+
+module.exports = ignoreCachedUpdates
+
+

package/src/methods/importState.js

@@ -0,0 +1,16 @@
+function importState (fsm) {
+return function ( {state, stateData} ) {
+// *** Import existing state to fsm
+        const { walk } = fsm.dependencies;
+        if ( state ) {
+                    fsm.state = state
+                    fsm.stateData = walk ( stateData )
+                    // TODO: test if stateData exist ??!
+            }
+}} // importState func.           
+
+
+
+module.exports = importState
+
+

package/src/methods/index.js

@@ -0,0 +1,48 @@
+const
+    _setTransitions      = require ( './_setTransitions'     )
+  , _updateStep          = require ( './_updateStep'         )
+  , _warn                = require ( './_warn'               )
+  , _transit             = require ( './_transit'            ) 
+  , _getChain            = require ( './_getChain'           )
+  , _triggerCacheUpdate  = require ( './_triggerCacheUpdate' )
+  , _onUpdateTask        = require ( './_onUpdateTask'       )
+
+  , setDependencies     = require ( './setDependencies'    )
+  , on                  = require ( './on'                 )
+  , off                 = require ( './off'                )
+  , importState         = require ( './importState'        )
+  , exportState         = require ( './exportState'        )
+  , update              = require ( './update'             )
+  , reset               = require ( './reset'              )
+  , ignoreCachedUpdates = require ( './ignoreCacheUpdates' )
+  , getState            = require ( './getState'           )
+  ;
+
+
+
+const fn = {
+// *** "Private" methods
+              _setTransitions     // Convert machine configuration and transition library in a internal fsm structures
+            , _updateStep         // Process results of transitions
+            , _warn               // Warn on issues if "debug:true" in machine configuration
+            , _transit            // Executes a transition if it is defined
+            , _getChain           // Returns chainAction for the key if available
+            , _triggerCacheUpdate // Call next transition from the cache
+            , _onUpdateTask       // Executes on update success. Used in "update" and "_triggerCacheUpdate"
+// *** Public methods
+            , setDependencies          // Add objects in dependencies
+            , on                       // Register callback functions on: 'update', 'transition', 'negative', 'positive'
+            , off                      // Remove callbacks
+            , importState              // Get state and data from outside
+            , exportState              // Extract state from fsm
+            , update                   // Trigger an action on fsm
+            , reset                    // Change state and stateData to initial values
+            , ignoreCachedUpdates      // Disable update records in the cache
+            , getState                 // Return a state value
+        }
+
+
+
+module.exports = fn
+
+

package/src/methods/off.js

@@ -0,0 +1,11 @@
+function off ( fsm ) {
+return function ( eName ) {
+        if ( !fsm.callback[eName] )   return
+        fsm.callback[eName] = []
+}} // off func.
+
+
+
+module.exports = off
+
+