jssm 5.61.1 → 5.61.4

package/README.md

@@ -42,18 +42,39 @@ log( TrafficLight.state() );  // 'Green'
 What if the notation supported action names easily?
 
 ```javascript
-const TrafficLightWithActions = sm`Red 'next' -> Green 'next' -> Yellow 'next' -> Red;`;
+const TLWA = sm`Red 'next' -> Green 'next' -> Yellow 'next' -> Red;`;  // TLWA = Traffic Light With Actions
 
-log( TrafficLightWithActions.state() );  // 'Red'
+log( TLWA.state() );  // 'Red'
 
-TrafficLightWithActions.action('next');  // true
-log( TrafficLightWithActions.state() );  // 'Green'
+TLWA.action('next');  // true
+log( TLWA.state() );  // 'Green'
 
-TrafficLightWithActions.action('next');  // true
-log( TrafficLightWithActions.state() );  // 'Yellow'
+TLWA.action('next');  // true
+log( TLWA.state() );  // 'Yellow'
 
-TrafficLightWithActions.action('next');  // true
-log( TrafficLightWithActions.state() );  // 'Red'
+TLWA.action('next');  // true
+log( TLWA.state() );  // 'Red'
+```
+
+<br/>
+
+What if integration with the outside was straightforward?
+
+```javascript
+const MTL = sm`Red 'next' -> Green 'next' -> Yellow 'next' -> Red;`  // MTL = More Traffic Lights
+              .hook('Red', 'Green', () => console.log('GO GO GO'))   // node will jump the gun when you hit return, though
+              .hook_entry('Red', () => console.log('STOP'));         // so put it on one line in node
+
+log( MTL.state() );  // 'Red'
+
+TLWA.action('next');  // true, console logs 'GO GO GO'
+log( TLWA.state() );  // 'Green'
+
+TLWA.action('next');  // true
+log( TLWA.state() );  // 'Yellow'
+
+TLWA.action('next');  // true, console logs 'STOP'
+log( TLWA.state() );  // 'Red'
 ```
 
 <br/>
@@ -61,11 +82,11 @@ log( TrafficLightWithActions.state() );  // 'Red'
 What if the machine followed JS standards, and distinguished refusals as `false` from mistakes as `throw`n?
 
 ```javascript
-const AnotherTrafficLight = sm`Red -> Green -> Yellow -> Red;`;
+const ATL = sm`Red -> Green -> Yellow -> Red;`;  // ATL = Another Traffic Light
 
-log( AnotherTrafficLight.state() );         // 'Red' - uses 1st state unless told otherwise
-AnotherTrafficLight.transition('Yellow');   // false (Yellow isn't allowed from Red)
-AnotherTrafficLight.transition('Blue');     // throws (Blue isn't a state at all)
+log( ATL.state() );         // 'Red' - uses 1st state unless told otherwise
+ATL.transition('Yellow');   // false (Yellow isn't allowed from Red)
+ATL.transition('Blue');     // throws (Blue isn't a state at all)
 ```
 
 <br/>

package/dist/es6/jssm.d.ts

@@ -42,6 +42,8 @@ declare class Machine<mDT> {
     _has_named_hooks: boolean;
     _has_entry_hooks: boolean;
     _has_exit_hooks: boolean;
+    _has_global_action_hooks: boolean;
+    _has_transition_hooks: boolean;
     _hooks: Map<string, Function>;
     _named_hooks: Map<string, Function>;
     _entry_hooks: Map<string, Function>;

package/dist/es6/jssm.js

@@ -350,6 +350,8 @@ class Machine {
         this._has_named_hooks = false;
         this._has_entry_hooks = false;
         this._has_exit_hooks = false;
+        this._has_global_action_hooks = false;
+        this._has_transition_hooks = true;
         // no need for a boolean has any transition hook, as it's one or nothing, so just test that for undefinedness
         this._hooks = new Map();
         this._named_hooks = new Map();
@@ -719,14 +721,17 @@ class Machine {
             case 'hook':
                 this._hooks.set(hook_name(HookDesc.from, HookDesc.to), HookDesc.handler);
                 this._has_hooks = true;
+                this._has_basic_hooks = true;
                 break;
             case 'named':
                 this._named_hooks.set(named_hook_name(HookDesc.from, HookDesc.to, HookDesc.action), HookDesc.handler);
                 this._has_hooks = true;
+                this._has_named_hooks = true;
                 break;
             case 'global action':
                 this._global_action_hooks.set(HookDesc.action, HookDesc.handler);
                 this._has_hooks = true;
+                this._has_global_action_hooks = true;
                 break;
             case 'any action':
                 this._any_action_hook = HookDesc.handler;
@@ -734,14 +739,17 @@ class Machine {
                 break;
             case 'standard transition':
                 this._standard_transition_hook = HookDesc.handler;
+                this._has_transition_hooks = true;
                 this._has_hooks = true;
                 break;
             case 'main transition':
                 this._main_transition_hook = HookDesc.handler;
+                this._has_transition_hooks = true;
                 this._has_hooks = true;
                 break;
             case 'forced transition':
                 this._forced_transition_hook = HookDesc.handler;
+                this._has_transition_hooks = true;
                 this._has_hooks = true;
                 break;
             case 'any transition':
@@ -751,10 +759,12 @@ class Machine {
             case 'entry':
                 this._entry_hooks.set(HookDesc.to, HookDesc.handler);
                 this._has_hooks = true;
+                this._has_entry_hooks = true;
                 break;
             case 'exit':
                 this._exit_hooks.set(HookDesc.from, HookDesc.handler);
                 this._has_hooks = true;
+                this._has_exit_hooks = true;
                 break;
             default:
                 console.log(`Unknown hook type ${HookDesc.kind}, should be impossible`);
@@ -838,8 +848,10 @@ class Machine {
         }
         else {
             if (this.valid_transition(newStateOrAction, newData)) {
+                if (this._has_transition_hooks) {
+                    trans_type = this.edges_between(this._state, newStateOrAction)[0].kind; // TODO this won't do the right thing if various edges have different types
+                }
                 valid = true;
-                trans_type = this.edges_between(this._state, newStateOrAction)[0].kind; // TODO this won't do the right thing if various edges have different types
                 newState = newStateOrAction;
             }
         }
@@ -869,26 +881,32 @@ class Machine {
                     }
                 }
                 // 4. exit hook
-                const maybe_ex_hook = this._exit_hooks.get(this._state);
-                if (maybe_ex_hook !== undefined) {
-                    if (maybe_ex_hook({ from: this._state, forced: wasForced }) === false) {
-                        return false;
+                if (this._has_exit_hooks) {
+                    const maybe_ex_hook = this._exit_hooks.get(this._state);
+                    if (maybe_ex_hook !== undefined) {
+                        if (maybe_ex_hook({ from: this._state, forced: wasForced }) === false) {
+                            return false;
+                        }
                     }
                 }
                 // 5. named transition / action hook
-                if (wasAction) {
-                    const nhn = named_hook_name(this._state, newState, newStateOrAction), n_maybe_hook = this._named_hooks.get(nhn);
-                    if (n_maybe_hook !== undefined) {
-                        if (n_maybe_hook({ from: this._state, to: newState, action: newStateOrAction }) === false) {
-                            return false;
+                if (this._has_named_hooks) {
+                    if (wasAction) {
+                        const nhn = named_hook_name(this._state, newState, newStateOrAction), n_maybe_hook = this._named_hooks.get(nhn);
+                        if (n_maybe_hook !== undefined) {
+                            if (n_maybe_hook({ from: this._state, to: newState, action: newStateOrAction }) === false) {
+                                return false;
+                            }
                         }
                     }
                 }
                 // 6. regular hook
-                const hn = hook_name(this._state, newState), maybe_hook = this._hooks.get(hn);
-                if (maybe_hook !== undefined) {
-                    if (maybe_hook({ from: this._state, to: newState, forced: wasForced, action: wasAction ? newStateOrAction : undefined }) === false) {
-                        return false;
+                if (this._has_basic_hooks) {
+                    const hn = hook_name(this._state, newState), maybe_hook = this._hooks.get(hn);
+                    if (maybe_hook !== undefined) {
+                        if (maybe_hook({ from: this._state, to: newState, forced: wasForced, action: wasAction ? newStateOrAction : undefined }) === false) {
+                            return false;
+                        }
                     }
                 }
                 // 7. edge type hook
@@ -923,10 +941,12 @@ class Machine {
                     }
                 }
                 // 8. entry hook
-                const maybe_en_hook = this._entry_hooks.get(newState);
-                if (maybe_en_hook !== undefined) {
-                    if (maybe_en_hook({ to: newState, forced: wasForced }) === false) {
-                        return false;
+                if (this._has_entry_hooks) {
+                    const maybe_en_hook = this._entry_hooks.get(newState);
+                    if (maybe_en_hook !== undefined) {
+                        if (maybe_en_hook({ to: newState, forced: wasForced }) === false) {
+                            return false;
+                        }
                     }
                 }
                 this._state = newState;

package/dist/es6/version.js

@@ -1,2 +1,2 @@
-const version = "5.61.1";
+const version = "5.61.4";
 export { version };