jssm 5.59.1 → 5.60.4

package/dist/es6/jssm.d.ts

@@ -48,6 +48,9 @@ declare class Machine<mDT> {
     _exit_hooks: Map<string, Function>;
     _global_action_hooks: Map<string, Function>;
     _any_action_hook: HookHandler | undefined;
+    _standard_transition_hook: HookHandler | undefined;
+    _main_transition_hook: HookHandler | undefined;
+    _forced_transition_hook: HookHandler | undefined;
     _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;
@@ -103,9 +106,13 @@ declare class Machine<mDT> {
     hook_action(from: string, to: string, action: string, handler: HookHandler): Machine<mDT>;
     hook_global_action(action: string, handler: HookHandler): Machine<mDT>;
     hook_any_action(handler: HookHandler): Machine<mDT>;
+    hook_standard_transition(handler: HookHandler): Machine<mDT>;
+    hook_main_transition(handler: HookHandler): Machine<mDT>;
+    hook_forced_transition(handler: HookHandler): Machine<mDT>;
     hook_any_transition(handler: HookHandler): Machine<mDT>;
     hook_entry(to: string, handler: HookHandler): Machine<mDT>;
     hook_exit(from: string, handler: HookHandler): Machine<mDT>;
+    edges_between(from: string, to: string): JssmTransition<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

@@ -357,7 +357,11 @@ class Machine {
         this._exit_hooks = new Map();
         this._global_action_hooks = new Map();
         this._any_action_hook = undefined;
+        this._standard_transition_hook = undefined;
+        this._main_transition_hook = undefined;
+        this._forced_transition_hook = undefined;
         this._any_transition_hook = undefined;
+        this._standard_transition_hook = undefined;
         if (state_declaration) {
             state_declaration.map((state_decl) => {
                 if (this._state_declarations.has(state_decl.state)) { // no repeats
@@ -728,6 +732,18 @@ class Machine {
                 this._any_action_hook = HookDesc.handler;
                 this._has_hooks = true;
                 break;
+            case 'standard transition':
+                this._standard_transition_hook = HookDesc.handler;
+                this._has_hooks = true;
+                break;
+            case 'main transition':
+                this._main_transition_hook = HookDesc.handler;
+                this._has_hooks = true;
+                break;
+            case 'forced transition':
+                this._forced_transition_hook = HookDesc.handler;
+                this._has_hooks = true;
+                break;
             case 'any transition':
                 this._any_transition_hook = HookDesc.handler;
                 this._has_hooks = true;
@@ -765,6 +781,21 @@ class Machine {
         this.set_hook({ kind: 'any action', handler });
         return this;
     }
+    hook_standard_transition(handler) {
+        // TODO: should this throw if setting the hook fails, or ignore it and continue?
+        this.set_hook({ kind: 'standard transition', handler });
+        return this;
+    }
+    hook_main_transition(handler) {
+        // TODO: should this throw if setting the hook fails, or ignore it and continue?
+        this.set_hook({ kind: 'main transition', handler });
+        return this;
+    }
+    hook_forced_transition(handler) {
+        // TODO: should this throw if setting the hook fails, or ignore it and continue?
+        this.set_hook({ kind: 'forced transition', 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 });
@@ -783,11 +814,17 @@ class Machine {
     // remove_hook(HookDesc: HookDescription) {
     //   throw 'TODO: Should remove hook here';
     // }
+    edges_between(from, to) {
+        return this._edges.filter(edge => ((edge.from === from) && (edge.to === to)));
+    }
     transition_impl(newStateOrAction, newData, wasForced, wasAction) {
-        let valid = false, newState;
+        // TODO the forced-ness behavior needs to be cleaned up a lot here
+        // TODO all the callbacks are wrong on forced, action, etc
+        let valid = false, trans_type, newState;
         if (wasForced) {
             if (this.valid_force_transition(newStateOrAction, newData)) {
                 valid = true;
+                trans_type = 'forced';
                 newState = newStateOrAction;
             }
         }
@@ -795,12 +832,14 @@ class Machine {
             if (this.valid_action(newStateOrAction, newData)) {
                 const edge = this.current_action_edge_for(newStateOrAction);
                 valid = true;
+                trans_type = edge.kind;
                 newState = edge.to;
             }
         }
         else {
             if (this.valid_transition(newStateOrAction, newData)) {
                 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;
             }
         }
@@ -853,7 +892,36 @@ class Machine {
                     }
                 }
                 // 7. edge type hook
-                // not yet implemented
+                // 7a. standard transition hook
+                if (trans_type === 'legal') {
+                    if (this._standard_transition_hook !== undefined) {
+                        // todo handle actions
+                        // todo handle forced
+                        if (this._standard_transition_hook({ from: this._state, to: newState }) === false) {
+                            return false;
+                        }
+                    }
+                }
+                // 7b. main type hook
+                if (trans_type === 'main') {
+                    if (this._main_transition_hook !== undefined) {
+                        // todo handle actions
+                        // todo handle forced
+                        if (this._main_transition_hook({ from: this._state, to: newState }) === false) {
+                            return false;
+                        }
+                    }
+                }
+                // 7c. forced transition hook
+                if (trans_type === 'forced') {
+                    if (this._forced_transition_hook !== undefined) {
+                        // todo handle actions
+                        // todo handle forced
+                        if (this._forced_transition_hook({ from: this._state, to: newState }) === false) {
+                            return false;
+                        }
+                    }
+                }
                 // 8. entry hook
                 const maybe_en_hook = this._entry_hooks.get(newState);
                 if (maybe_en_hook !== undefined) {

package/dist/es6/jssm_types.d.ts

@@ -162,6 +162,18 @@ declare type HookDescriptionWithAction = {
     action: string;
     handler: HookHandler;
 };
+declare type StandardTransitionHook = {
+    kind: 'standard transition';
+    handler: HookHandler;
+};
+declare type MainTransitionHook = {
+    kind: 'main transition';
+    handler: HookHandler;
+};
+declare type ForcedTransitionHook = {
+    kind: 'forced transition';
+    handler: HookHandler;
+};
 declare type AnyTransitionHook = {
     kind: 'any transition';
     handler: HookHandler;
@@ -185,5 +197,5 @@ declare type ExitHook = {
     from: string;
     handler: HookHandler;
 };
-declare type HookDescription = BasicHookDescription | HookDescriptionWithAction | GlobalActionHook | AnyActionHook | AnyTransitionHook | EntryHook | ExitHook;
+declare type HookDescription = BasicHookDescription | HookDescriptionWithAction | GlobalActionHook | AnyActionHook | StandardTransitionHook | MainTransitionHook | ForcedTransitionHook | 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.59.1";
+const version = "5.60.4";
 export { version };