jssm 5.48.0 → 5.51.0

package/dist/es6/jssm.d.ts

@@ -38,8 +38,11 @@ declare class Machine<mDT> {
     _theme: FslTheme;
     _flow: FslDirection;
     _has_hooks: boolean;
+    _has_basic_hooks: boolean;
+    _has_named_hooks: boolean;
     _hooks: Map<string, Function>;
     _named_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;
     state(): StateType;
@@ -92,7 +95,9 @@ declare class Machine<mDT> {
     set_hook(HookDesc: HookDescription): void;
     hook(from: string, to: string, handler: HookHandler): Machine<mDT>;
     hook_action(from: string, to: string, action: string, handler: HookHandler): Machine<mDT>;
-    action(name: StateType, newData?: mDT): boolean;
+    hook_any_transition(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;
     force_transition(newState: StateType, newData?: mDT): boolean;
     current_action_for(action: StateType): number;

package/dist/es6/jssm.js

@@ -152,13 +152,13 @@ function makeTransition(this_se, from, to, isRight, _wasList, _wasIndex) {
     //  if ((wasIndex !== undefined) && (wasList  === undefined)) { throw new TypeError("Must be in a list if transition has an index");   }
     /*
       if (typeof edge.to === 'object') {
-    
+  
         if (edge.to.key === 'cycle') {
           if (wasList === undefined) { throw "Must have a waslist if a to is type cycle"; }
           const nextIndex = wrapBy(wasIndex, edge.to.value, wasList.length);
           edge.to = wasList[nextIndex];
         }
-    
+  
       }
     */
     const action = isRight ? 'r_action' : 'l_action', probability = isRight ? 'r_probability' : 'l_probability';
@@ -346,8 +346,11 @@ class Machine {
         this._flow = flow;
         this._graph_layout = graph_layout;
         this._has_hooks = false;
+        this._has_basic_hooks = false;
+        this._has_named_hooks = false;
         this._hooks = new Map();
         this._named_hooks = new Map();
+        this._any_transition_hook = undefined;
         if (state_declaration) {
             state_declaration.map((state_decl) => {
                 if (this._state_declarations.has(state_decl.state)) { // no repeats
@@ -456,7 +459,7 @@ class Machine {
     }
     /* whargarbl todo major
        when we reimplement this, reintroduce this change to the is_final call
-    
+  
       is_changing(): boolean {
         return true; // todo whargarbl
       }
@@ -655,7 +658,8 @@ class Machine {
         return Array.from(ra_base.values())
             .map((edgeId) => this._edges[edgeId])
             .filter((o) => o.from === whichState)
-            .map((filtered) => ({ action: filtered.action,
+            .map((filtered) => ({
+            action: filtered.action,
             probability: filtered.probability
         }));
     }
@@ -709,6 +713,10 @@ class Machine {
                 this._named_hooks.set(named_hook_name(HookDesc.from, HookDesc.to, HookDesc.action), HookDesc.handler);
                 this._has_hooks = true;
                 break;
+            case 'any transition':
+                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';
@@ -730,54 +738,63 @@ class Machine {
         this.set_hook({ kind: 'named', from, to, action, handler });
         return this;
     }
+    hook_any_transition(handler) {
+        // TODO: should this throw if setting the hook fails, or ignore it and continue?
+        this.set_hook({ kind: 'any transition', handler });
+        return this;
+    }
     // remove_hook(HookDesc: HookDescription) {
     //   throw 'TODO: Should remove hook here';
     // }
-    action(name, newData) {
-        // todo whargarbl implement hooks
-        // todo whargarbl implement data stuff
-        // todo major incomplete whargarbl comeback
-        if (this.valid_action(name, newData)) {
-            const edge = this.current_action_edge_for(name);
-            if (this._has_hooks) {
-                let hook_permits = undefined;
-                const nhn = named_hook_name(this._state, edge.to, name), maybe_hook = this._named_hooks.get(nhn);
-                if (maybe_hook === undefined) {
-                    hook_permits = true;
-                }
-                else {
-                    hook_permits = maybe_hook({ from: this._state, to: edge.to, action: name });
-                }
-                if (hook_permits !== false) {
-                    this._state = edge.to;
-                    return true;
-                }
-                else {
-                    return false;
-                }
+    transition_impl(newStateOrAction, newData, wasForced, wasAction) {
+        let valid = false, newState;
+        if (wasForced) {
+            if (this.valid_force_transition(newStateOrAction, newData)) {
+                valid = true;
+                newState = newStateOrAction;
             }
-            else {
-                this._state = edge.to;
-                return true;
+        }
+        else if (wasAction) {
+            if (this.valid_action(newStateOrAction, newData)) {
+                const edge = this.current_action_edge_for(newStateOrAction);
+                valid = true;
+                newState = edge.to;
             }
         }
         else {
-            return false;
+            if (this.valid_transition(newStateOrAction, newData)) {
+                valid = true;
+                newState = newStateOrAction;
+            }
         }
-    }
-    transition(newState, newData) {
-        // todo whargarbl implement hooks
         // todo whargarbl implement data stuff
         // todo major incomplete whargarbl comeback
-        if (this.valid_transition(newState, newData)) {
+        if (valid) {
             if (this._has_hooks) {
                 let hook_permits = undefined;
+                if (this._any_transition_hook !== undefined) {
+                    if (this._any_transition_hook() === false) {
+                        return false;
+                    }
+                }
+                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;
+                    }
+                }
                 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 });
+                    hook_permits = maybe_hook({ from: this._state, to: newState, forced: wasForced, action: wasAction ? newStateOrAction : undefined });
                 }
                 if (hook_permits !== false) {
                     this._state = newState;
@@ -796,37 +813,15 @@ class Machine {
             return false;
         }
     }
+    action(actionName, newData) {
+        return this.transition_impl(actionName, newData, false, true);
+    }
+    transition(newState, newData) {
+        return this.transition_impl(newState, newData, false, false);
+    }
     // can leave machine in inconsistent state.  generally do not use
     force_transition(newState, newData) {
-        // todo whargarbl implement hooks
-        // todo whargarbl implement data stuff
-        // todo major incomplete whargarbl comeback
-        if (this.valid_force_transition(newState, newData)) {
-            if (this._has_hooks) {
-                let hook_permits = undefined;
-                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: true });
-                }
-                if (hook_permits !== false) {
-                    this._state = newState;
-                    return true;
-                }
-                else {
-                    return false;
-                }
-            }
-            else {
-                this._state = newState;
-                return true;
-            }
-        }
-        else {
-            return false;
-        }
+        return this.transition_impl(newState, newData, true, false);
     }
     current_action_for(action) {
         const action_base = this._actions.get(action);

package/dist/es6/jssm_types.d.ts

@@ -162,6 +162,10 @@ declare type HookDescriptionWithAction = {
     action: string;
     handler: HookHandler;
 };
+declare type AnyTransitionHook = {
+    kind: 'any transition';
+    handler: HookHandler;
+};
 declare type EntryHook = {
     kind: 'entry';
     to: string;
@@ -172,5 +176,5 @@ declare type ExitHook = {
     from: string;
     handler: HookHandler;
 };
-declare type HookDescription = BasicHookDescription | HookDescriptionWithAction | EntryHook | ExitHook;
+declare type HookDescription = BasicHookDescription | HookDescriptionWithAction | AnyTransitionHook | EntryHook | ExitHook;
 export { JssmColor, JssmTransition, JssmTransitions, JssmTransitionList, JssmTransitionRule, JssmArrow, JssmArrowKind, JssmArrowDirection, JssmGenericConfig, JssmGenericState, JssmGenericMachine, JssmParseTree, JssmCompileSe, JssmCompileSeStart, JssmCompileRule, JssmPermitted, JssmPermittedOpt, JssmResult, JssmStateDeclaration, JssmStateDeclarationRule, JssmLayout, JssmParseFunctionType, JssmMachineInternalState, FslDirection, FslTheme, HookDescription, HookHandler };

package/dist/es6/version.js

@@ -1,2 +1,2 @@
-const version = "5.48.0";
+const version = "5.51.0";
 export { version };