Break out invoke types

.github/workflows/nodejs.yml

@@ -21,7 +21,7 @@ jobs:
       uses: ianwalter/[email protected]
     - name: npm install, build, and test
       run: |
-        yarn
+        npm ci
         npm run server &
         npm run bundlesize
         npm test

bundlesize.json

@@ -2,7 +2,7 @@
   "files": [
     {
       "path": "./machine.min.js",
-      "maxSize": "1.347 kB"
+      "maxSize": "1.39 kB"
     }
   ]
 }

machine.js

@@ -54,7 +54,7 @@ export let transition = makeTransition.bind(transitionType);
 export let immediate = makeTransition.bind(immediateType, null);
 
 function enterImmediate(machine, service, event) {
-  return transitionTo(service, event, this.immediates) || machine;
+  return transitionTo(service, machine, event, this.immediates) || machine;
 }
 
 function transitionsToMap(transitions) {
@@ -81,33 +81,42 @@ export function state(...args) {
   return create(stateType, desc);
 }
 
-let invokeType = {
+let invokePromiseType = {
   enter(machine, service, event) {
     this.fn.call(service, service.context, event)
       .then(data => service.send({ type: 'done', data }))
       .catch(error => service.send({ type: 'error', error }));
     return machine;
   }
 };
-const machineToThen = machine => function(ctx, ev) {
-  return {
-    then: resolve => {
-      this.child = interpret(machine, s => {
-        this.onChange(s);
-        if(this.child == s && s.machine.state.value.final) {
-          delete this.child;
-          resolve(s.context);
-        }
-      }, ctx, ev);
-      return { catch: identity };
+let invokeMachineType = {
+  enter(machine, service, event) {
+    service.child = interpret(this.machine, s => {
+      service.onChange(s);
+      if(service.child == s && s.machine.state.value.final) {
+        delete service.child;
+        service.send({ type: 'done', data: s.context });
+      }
+    }, service.context, event);
+    if(service.child.machine.state.value.final) {
+      let data = service.child.context;
+      delete service.child;
+      return transitionTo(service, machine, { type: 'done', data }, this.transitions.get('done'));
     }
-  };
+    return machine;
+  }
 };
 export function invoke(fn, ...transitions) {
-  return create(invokeType, {
-    fn: valueEnumerable(machine.isPrototypeOf(fn) ? machineToThen(fn) : fn),
-    transitions: valueEnumerable(transitionsToMap(transitions))
-  });
+  let t = valueEnumerable(transitionsToMap(transitions));
+  return machine.isPrototypeOf(fn) ?
+    create(invokeMachineType, {
+      machine: valueEnumerable(fn),
+      transitions: t
+    }) :
+    create(invokePromiseType, {
+      fn: valueEnumerable(machine.isPrototypeOf(fn) ? machineToThen(fn) : fn),
+      transitions: t
+    });
 }
 
 let machine = {
@@ -133,8 +142,8 @@ export function createMachine(current, states, contextFn = empty) {
   });
 }
 
-function transitionTo(service, fromEvent, candidates) {
-  let { machine, context } = service;
+function transitionTo(service, machine, fromEvent, candidates) {
+  let { context } = service;
   for(let { to, guards, reducers } of candidates) {  
     if(guards(context, fromEvent)) {
       service.context = reducers.call(service, context, fromEvent);
@@ -157,7 +166,7 @@ function send(service, event) {
   let { value: state } = machine.state;
 
   if(state.transitions.has(eventName)) {
-    return transitionTo(service, event, state.transitions.get(eventName)) || machine;
+    return transitionTo(service, machine, event, state.transitions.get(eventName)) || machine;
   }
   return machine;
 }

test/test-immediate.js

@@ -33,4 +33,20 @@ QUnit.module('Immediate', hooks => {
     service.send('next');
     assert.equal(service.machine.current, 'three');
   });
+
+  QUnit.test('Can immediately transitions past 2 states', assert => {
+    let machine = createMachine({
+      one: state(
+        immediate('two')
+      ),
+      two: state(
+        immediate('three')
+      ),
+      three: state()
+    });
+
+    let service = interpret(machine, () => {});
+    assert.equal(service.machine.current, 'three', 'transitioned to 3');
+    assert.ok(service.machine.state.value.final, 'in the final state');
+  });
 });

test/test-invoke.js

@@ -57,10 +57,10 @@ QUnit.module('Invoke', hooks => {
   QUnit.test('Can invoke a child machine', async assert => {
     assert.expect(4);
     let one = createMachine({
-      one: state(
-        transition('go', 'two')
+      nestedOne: state(
+        transition('go', 'nestedTwo')
       ),
-      two: final()
+      nestedTwo: final()
     });
     let two = createMachine({
       one: state(
@@ -246,4 +246,33 @@ QUnit.module('Invoke', hooks => {
     service.child.child.child.send('DONE') // machine four
     assert.equal(c, 8, 'there were 6 transitions');
   });
+
+  QUnit.test('Invoking a machine that immediately finishes', async assert => {
+    assert.expect(1);
+
+    const child = createMachine({
+      nestedOne: state(
+        immediate('nestedTwo')
+      ),
+      nestedTwo: final()
+    });
+
+    const parent = createMachine({
+      one: state(
+        transition('next', 'two')
+      ),
+      two: invoke(child,
+        transition('done', 'three')
+      ),
+      three: final()
+    });
+
+    let service = interpret(parent, s => {
+      // TODO not totally sure if this is correct, but I think it should
+      // hit this only once and be equal to three
+      assert.equal(s.machine.current, 'three');
+    });
+
+    service.send('next');
+  });
 });

test/test-state.js

@@ -1,4 +1,4 @@
-import { createMachine, interpret, invoke, state, transition } from '../machine.js';
+import { createMachine, interpret, invoke, reduce, state, transition } from '../machine.js';
 
 QUnit.module('States', hooks => {
   QUnit.test('Basic state change', assert => {
@@ -60,10 +60,18 @@ QUnit.module('States', hooks => {
       start: state(
         transition('next', 'next')
       ),
-      next: invoke(child)
+      next: invoke(child,
+        transition('done', 'end',
+          reduce((ctx, ev) => ({
+            ...ctx,
+            ...ev.data
+          }))
+        )
+      ),
+      end: state()
     });
     let service = interpret(parent, () => {});
     service.send({ type: 'next', count: 14 });
-    assert.equal(service.child.context.count, 14, 'event sent through');
+    assert.equal(service.context.count, 14, 'event sent through');
   });
 });