jssm 5.55.0 → 5.57.0

package/dist/es6/jssm.d.ts

@@ -40,8 +40,12 @@ declare class Machine<mDT> {
     _has_hooks: boolean;
     _has_basic_hooks: boolean;
     _has_named_hooks: boolean;
+    _has_entry_hooks: boolean;
+    _has_exit_hooks: boolean;
     _hooks: Map<string, Function>;
     _named_hooks: Map<string, Function>;
+    _entry_hooks: Map<string, Function>;
+    _exit_hooks: Map<string, Function>;
     _any_transition_hook: HookHandler | undefined;
     constructor({ start_states, complete, transitions, machine_author, machine_comment, machine_contributor, machine_definition, machine_language, machine_license, machine_name, machine_version, state_declaration, fsl_version, dot_preamble, arrange_declaration, arrange_start_declaration, arrange_end_declaration, theme, flow, graph_layout }: JssmGenericConfig<mDT>);
     _new_state(state_config: JssmGenericState): StateType;
@@ -96,6 +100,7 @@ declare class Machine<mDT> {
     hook(from: string, to: string, handler: HookHandler): Machine<mDT>;
     hook_action(from: string, to: string, action: string, handler: HookHandler): Machine<mDT>;
     hook_any_transition(handler: HookHandler): Machine<mDT>;
+    hook_entry(to: string, handler: HookHandler): Machine<mDT>;
     transition_impl(newStateOrAction: StateType, newData: mDT | undefined, wasForced: boolean, wasAction: boolean): boolean;
     action(actionName: StateType, newData?: mDT): boolean;
     transition(newState: StateType, newData?: mDT): boolean;

package/dist/es6/jssm.js

@@ -348,8 +348,13 @@ class Machine {
         this._has_hooks = false;
         this._has_basic_hooks = false;
         this._has_named_hooks = false;
+        this._has_entry_hooks = false;
+        this._has_exit_hooks = false;
+        // 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();
+        this._entry_hooks = new Map();
+        this._exit_hooks = new Map();
         this._any_transition_hook = undefined;
         if (state_declaration) {
             state_declaration.map((state_decl) => {
@@ -717,12 +722,14 @@ class Machine {
                 this._any_transition_hook = HookDesc.handler;
                 this._has_hooks = true;
                 break;
-            // case 'entry':
-            //   console.log('TODO: Should add entry hook here');
-            //   throw 'TODO: Should add entry hook here';
-            // case 'exit':
-            //   console.log('TODO: Should add exit hook here');
-            //   throw 'TODO: Should add exit hook here';
+            case 'entry':
+                this._entry_hooks.set(HookDesc.to, HookDesc.handler);
+                this._has_hooks = true;
+                break;
+            case 'exit':
+                this._exit_hooks.set(HookDesc.from, HookDesc.handler);
+                this._has_hooks = true;
+                break;
             default:
                 console.log(`Unknown hook type ${HookDesc.kind}, should be impossible`);
                 throw new RangeError(`Unknown hook type ${HookDesc.kind}, should be impossible`);
@@ -743,6 +750,11 @@ class Machine {
         this.set_hook({ kind: 'any transition', handler });
         return this;
     }
+    hook_entry(to, handler) {
+        // TODO: should this throw if setting the hook fails, or ignore it and continue?
+        this.set_hook({ kind: 'entry', to, handler });
+        return this;
+    }
     // remove_hook(HookDesc: HookDescription) {
     //   throw 'TODO: Should remove hook here';
     // }
@@ -771,43 +783,55 @@ class Machine {
         // todo major incomplete whargarbl comeback
         if (valid) {
             if (this._has_hooks) {
-                let hook_permits = undefined;
+                // 1. any action hook
+                // not yet implemented
+                // 2. any transition hook
                 if (this._any_transition_hook !== undefined) {
                     if (this._any_transition_hook() === false) {
                         return false;
                     }
                 }
+                // 3. 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;
+                    }
+                }
+                // 4. 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) {
-                        hook_permits = true;
-                    }
-                    else {
-                        hook_permits = n_maybe_hook({ from: this._state, to: newState, action: newStateOrAction });
-                    }
-                    if (!(hook_permits)) {
-                        return false;
+                    if (n_maybe_hook !== undefined) {
+                        if (n_maybe_hook({ from: this._state, to: newState, action: newStateOrAction }) === false) {
+                            return false;
+                        }
                     }
                 }
+                // 5. regular hook
                 const hn = hook_name(this._state, newState), maybe_hook = this._hooks.get(hn);
-                if (maybe_hook === undefined) {
-                    hook_permits = true;
-                }
-                else {
-                    hook_permits = maybe_hook({ from: this._state, to: newState, forced: wasForced, action: wasAction ? newStateOrAction : undefined });
-                }
-                if (hook_permits !== false) {
-                    this._state = newState;
-                    return true;
+                if (maybe_hook !== undefined) {
+                    if (maybe_hook({ from: this._state, to: newState, forced: wasForced, action: wasAction ? newStateOrAction : undefined }) === false) {
+                        return false;
+                    }
                 }
-                else {
-                    return false;
+                // 6. edge type hook
+                // not yet implemented
+                // 7. 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;
+                    }
                 }
+                this._state = newState;
+                return true;
+                // or without hooks
             }
             else {
                 this._state = newState;
                 return true;
             }
+            // not valid
         }
         else {
             return false;

package/dist/es6/version.js

@@ -1,2 +1,2 @@
-const version = "5.55.0";
+const version = "5.57.0";
 export { version };