xstate 3.2.1 → 3.3.3

package/test/activities.test.ts

@@ -35,6 +35,57 @@ const lightMachine = Machine({
   }
 });
 
+describe('activities with guarded transitions', () => {
+  const machine = Machine({
+    initial: 'A',
+    states: {
+      A: {
+        on: {
+          E: 'B'
+        }
+      },
+      B: {
+        on: {
+          '': [{ cond: () => false, target: 'A' }]
+        },
+        activities: ['B_ACTIVITY']
+      }
+    }
+  });
+
+  it('should activate even if there are subsequent automatic, but blocked transitions', () => {
+    let state = machine.initialState;
+    state = machine.transition(state, 'E');
+    assert.deepEqual(state.activities, { B_ACTIVITY: true });
+  });
+});
+
+describe('remembering activities', () => {
+  const machine = Machine({
+    initial: 'A',
+    states: {
+      A: {
+        on: {
+          E: 'B'
+        }
+      },
+      B: {
+        on: {
+          E: 'A'
+        },
+        activities: ['B_ACTIVITY']
+      }
+    }
+  });
+
+  it('should remember the activities even after an event', () => {
+    let state = machine.initialState;
+    state = machine.transition(state, 'E');
+    state = machine.transition(state, 'IGNORE');
+    assert.deepEqual(state.activities, { B_ACTIVITY: true });
+  });
+});
+
 describe('activities', () => {
   it('identifies initial activities', () => {
     const { initialState } = lightMachine;
@@ -92,3 +143,117 @@ describe('activities', () => {
     ]);
   });
 });
+
+describe('transient activities', () => {
+  const machine = Machine({
+    parallel: true,
+    states: {
+      A: {
+        activities: ['A'],
+        initial: 'A1',
+        states: {
+          A1: {
+            activities: ['A1'],
+            on: {
+              A: 'AWAIT'
+            }
+          },
+          AWAIT: {
+            activities: ['AWAIT'],
+            on: {
+              '': 'A2'
+            }
+          },
+          A2: {
+            activities: ['A2'],
+            on: {
+              A: 'A1'
+            }
+          }
+        },
+        on: {
+          A1: '.A1',
+          A2: '.A2'
+        }
+      },
+      B: {
+        initial: 'B1',
+        activities: ['B'],
+        states: {
+          B1: {
+            activities: ['B1'],
+            on: {
+              '': [
+                {
+                  in: 'A.AWAIT',
+                  target: 'B2'
+                }
+              ],
+              B: 'B2'
+            }
+          },
+          B2: {
+            activities: ['B2'],
+            on: {
+              B: 'B1'
+            }
+          }
+        },
+        on: {
+          B1: '.B1',
+          B2: '.B2'
+        }
+      },
+      C: {
+        initial: 'C1',
+        states: {
+          C1: {
+            activities: ['C1'],
+            on: {
+              C: 'C1',
+              C_SIMILAR: 'C2'
+            }
+          },
+          C2: {
+            activities: ['C1'],
+          },
+        }
+      }
+    }
+  });
+
+  it('should have started initial activities', () => {
+    let state = machine.initialState;
+    assert.deepEqual(state.activities.A, true);
+  });
+
+  it('should have started deep initial activities', () => {
+    let state = machine.initialState;
+    assert.deepEqual(state.activities.A1, true);
+  });
+
+  it('should have kept existing activities', () => {
+    let state = machine.initialState;
+    state = machine.transition(state, 'A');
+    assert.deepEqual(state.activities.A, true);
+  });
+
+  it('should have kept same activities', () => {
+    let state = machine.initialState;
+    state = machine.transition(state, 'C_SIMILAR');
+    assert.deepEqual(state.activities.C1, true);
+  });
+
+  it('should have kept same activities after self transition', () => {
+    let state = machine.initialState;
+    state = machine.transition(state, 'C');
+    assert.deepEqual(state.activities.C1, true);
+  });
+
+  it('should have stopped after automatic transitions', () => {
+    let state = machine.initialState;
+    state = machine.transition(state, 'A');
+    assert.deepEqual(state.value, { A: 'A2', B: 'B2', C: 'C1' });
+    assert.deepEqual(state.activities.B2, true);
+  });
+});

package/test/deep.test.ts

@@ -6,7 +6,7 @@ describe('deep transitions', () => {
     key: 'deep',
     initial: 'A',
     on: {
-      MACHINE_EVENT: '#DONE'
+      MACHINE_EVENT: '#deep.DONE'
     },
     states: {
       DONE: {},
@@ -103,7 +103,7 @@ describe('deep transitions', () => {
       assert.deepEqual(actual, expected);
     });
 
-    xit('should exit substates and superstates when exiting (B_EVENT)', () => {
+    it('should exit substates and superstates when exiting (B_EVENT)', () => {
       const actual = deepMachine
         .transition(deepMachine.initialState, 'B_EVENT')
         .actions.map(a => `${a}`);
@@ -111,7 +111,7 @@ describe('deep transitions', () => {
       assert.deepEqual(actual, expected);
     });
 
-    xit('should exit substates and superstates when exiting (C_EVENT)', () => {
+    it('should exit substates and superstates when exiting (C_EVENT)', () => {
       const actual = deepMachine
         .transition(deepMachine.initialState, 'C_EVENT')
         .actions.map(a => `${a}`);
@@ -119,7 +119,7 @@ describe('deep transitions', () => {
       assert.deepEqual(actual, expected);
     });
 
-    xit('should exit superstates when exiting (D_EVENT)', () => {
+    it('should exit superstates when exiting (D_EVENT)', () => {
       const actual = deepMachine
         .transition(deepMachine.initialState, 'D_EVENT')
         .actions.map(a => `${a}`);
@@ -127,16 +127,14 @@ describe('deep transitions', () => {
       assert.deepEqual(actual, expected);
     });
 
-    xit(
-      'should exit substate when machine handles event (MACHINE_EVENT)',
-      () => {
-        const actual = deepMachine
-          .transition(deepMachine.initialState, 'MACHINE_EVENT')
-          .actions.map(a => `${a}`);
-        const expected = ['EXIT_D', 'EXIT_C', 'EXIT_B', 'EXIT_A'];
-        assert.deepEqual(actual, expected);
-      }
-    );
+    it('should exit substate when machine handles event (MACHINE_EVENT)', () => {
+      // console.log(deepMachine.initialState.value);
+      const actual = deepMachine
+        .transition(deepMachine.initialState, 'MACHINE_EVENT')
+        .actions.map(a => `${a}`);
+      const expected = ['EXIT_D', 'EXIT_C', 'EXIT_B', 'EXIT_A'];
+      assert.deepEqual(actual, expected);
+    });
 
     const DBCAPQRS = [
       'EXIT_D',
@@ -157,7 +155,7 @@ describe('deep transitions', () => {
       assert.deepEqual(actual, expected);
     });
 
-    xit('should exit deep and enter deep (D_P)', () => {
+    it('should exit deep and enter deep (D_P)', () => {
       const actual = deepMachine
         .transition(deepMachine.initialState, 'D_P')
         .actions.map(a => `${a}`);
@@ -173,7 +171,7 @@ describe('deep transitions', () => {
       assert.deepEqual(actual, expected);
     });
 
-    xit('should exit deep and enter deep (D_S)', () => {
+    it('should exit deep and enter deep (D_S)', () => {
       const actual = deepMachine
         .transition(deepMachine.initialState, 'D_S')
         .actions.map(a => `${a}`);

package/test/deterministic.test.ts

@@ -1,5 +1,5 @@
 import { assert } from 'chai';
-import { Machine } from '../src/index';
+import { Machine } from '../src/StateNode';
 
 describe('deterministic machine', () => {
   const pedestrianStates = {
@@ -135,10 +135,7 @@ describe('deterministic machine', () => {
     });
 
     it('should throw an error for transitions to invalid states', () => {
-      assert.throws(
-        () => testMachine.transition('a', 'F'),
-        "Event 'F' on state 'a' leads to undefined state 'c'."
-      );
+      assert.throws(() => testMachine.transition('a', 'F'));
     });
 
     it('should throw an error for transitions from invalid substates', () => {
@@ -206,4 +203,28 @@ describe('deterministic machine', () => {
       assert.equal(initialState, nextState);
     });
   });
+
+  describe('state key names', () => {
+    const machine = Machine({
+      key: 'test',
+      initial: 'test',
+      states: {
+        test: {
+          activities: ['activity'],
+          onEntry: ['onEntry'],
+          on: {
+            NEXT: 'test'
+          },
+          onExit: ['onExit']
+        }
+      }
+    });
+
+    it('should work with substate nodes that have the same key', () => {
+      assert.deepEqual(
+        machine.transition(machine.initialState, 'NEXT').value,
+        'test'
+      );
+    });
+  });
 });

package/test/examples/6.17.test.ts

@@ -65,3 +65,67 @@ describe('Example 6.17', () => {
     });
   });
 });
+
+describe('Jump to ID', () => {
+  const machine = Machine({
+    initial: 'X',
+    states: {
+      X: {
+        id: 'X',
+        on: {
+          1: 'Y',
+          2: 'Y.A.C', // 6.18
+          // 3: { Y: { A: 'C', B: 'F' } } // 6.19
+          4: 'Y.A.$history'
+        }
+      },
+      Y: {
+        parallel: true,
+        states: {
+          A: {
+            initial: 'D',
+            states: {
+              C: {
+                on: {
+                  finish: '#X'
+                }
+              },
+              D: {},
+              E: {}
+            }
+          },
+          B: {
+            initial: 'G',
+            states: { F: {}, G: {}, H: {} }
+          }
+        },
+        on: {
+          kill: '#X'
+        }
+      }
+    }
+  });
+
+  const expected = {
+    'Y.B.G': {
+      kill: 'X'
+    },
+    '{"Y":{"A":"C","B":"H"}}': {
+      finish: 'X'
+    }
+  };
+
+  Object.keys(expected).forEach(fromState => {
+    Object.keys(expected[fromState]).forEach(eventTypes => {
+      const toState = expected[fromState][eventTypes];
+
+      it(`should go from ${fromState} to ${JSON.stringify(
+        toState
+      )} on ${eventTypes}`, () => {
+        const resultState = testMultiTransition(machine, fromState, eventTypes);
+
+        assert.deepEqual(resultState.value, toState);
+      });
+    });
+  });
+});

package/test/fixtures/id.ts

@@ -1,4 +1,4 @@
-import { Machine } from '../../src/StateNode';
+import { Machine } from '../../src';
 
 export const machine = Machine({
   initial: 'A',

package/test/graph.test.ts

@@ -62,6 +62,27 @@ describe('graph utilities', () => {
     }
   });
 
+  const condMachine = Machine({
+    key: 'cond',
+    initial: 'pending',
+    states: {
+      pending: {
+        on: {
+          EVENT: [
+            { target: 'foo', cond: (_, e) => e.id === 'foo' },
+            { target: 'bar' }
+          ],
+          STATE: [
+            { target: 'foo', cond: s => s.id === 'foo' },
+            { target: 'bar' }
+          ]
+        }
+      },
+      foo: {},
+      bar: {}
+    }
+  });
+
   const parallelMachine = Machine({
     parallel: true,
     key: 'p',
@@ -342,24 +363,26 @@ describe('graph utilities', () => {
     });
 
     it('should not throw when a condition is present', () => {
-      const condMachine = Machine({
-        initial: 'a',
-        states: {
-          a: {
-            on: {
-              NEXT: {
-                b: {
-                  cond: payload => payload.foo
-                }
-              }
-            }
-          },
-          b: {}
-        }
-      });
-
       assert.doesNotThrow(() => getShortestPaths(condMachine));
     });
+
+    it('should represent conditional paths based on extended state', () => {
+      assert.deepEqual(getShortestPaths(condMachine, { id: 'foo' }), {
+        '"bar"': [
+          {
+            event: 'EVENT',
+            state: 'pending'
+          }
+        ],
+        '"foo"': [
+          {
+            event: 'STATE',
+            state: 'pending'
+          }
+        ],
+        '"pending"': []
+      });
+    });
   });
 
   describe('getShortestPathsAsArray()', () => {

package/test/guards.test.ts

@@ -1,26 +1,47 @@
 import { assert } from 'chai';
-import { Machine } from '../src/index';
+import { Machine, matchesState } from '../src/index';
 
 describe('guard conditions', () => {
-  const lightMachine = Machine({
-    key: 'light',
-    initial: 'green',
-    states: {
-      green: {
-        on: {
-          TIMER: {
-            green: {
-              cond: ({ elapsed }) => elapsed < 100
+  const lightMachine = Machine(
+    {
+      key: 'light',
+      initial: 'green',
+      states: {
+        green: {
+          on: {
+            TIMER: {
+              green: {
+                cond: ({ elapsed }) => elapsed < 100
+              },
+              yellow: {
+                cond: ({ elapsed }) => elapsed >= 100 && elapsed < 200
+              }
             },
-            yellow: {
-              cond: ({ elapsed }) => elapsed >= 100 && elapsed < 200
+            EMERGENCY: {
+              red: { cond: (_, event) => event.isEmergency }
+            }
+          }
+        },
+        yellow: {
+          on: {
+            TIMER: {
+              red: { cond: 'minTimeElapsed' }
             }
           }
+        },
+        red: {
+          on: {
+            BAD_COND: { red: { cond: 'doesNotExist' } }
+          }
         }
-      },
-      yellow: {}
+      }
+    },
+    {
+      guards: {
+        minTimeElapsed: ({ elapsed }) => elapsed >= 100 && elapsed < 200
+      }
     }
-  });
+  );
 
   it('should transition only if condition is met', () => {
     assert.equal(
@@ -42,6 +63,22 @@ describe('guard conditions', () => {
     );
   });
 
+  it('should transition if condition based on event is met', () => {
+    assert.equal(
+      lightMachine
+        .transition('green', { type: 'EMERGENCY', isEmergency: true })
+        .toString(),
+      'red'
+    );
+  });
+
+  it('should not transition if condition based on event is not met', () => {
+    assert.equal(
+      lightMachine.transition('green', { type: 'EMERGENCY' }).toString(),
+      'green'
+    );
+  });
+
   it('should not transition if no condition is met', () => {
     const nextState = lightMachine.transition('green', 'TIMER', {
       elapsed: 9000
@@ -49,4 +86,124 @@ describe('guard conditions', () => {
     assert.equal(nextState.value, 'green');
     assert.isEmpty(nextState.actions);
   });
+
+  it('should work with defined string transitions', () => {
+    const nextState = lightMachine.transition('yellow', 'TIMER', {
+      elapsed: 150
+    });
+    assert.equal(nextState.value, 'red');
+  });
+
+  it('should work with defined string transitions (condition not met)', () => {
+    const nextState = lightMachine.transition('yellow', 'TIMER', {
+      elapsed: 10
+    });
+    assert.equal(nextState.value, 'yellow');
+  });
+
+  it('should throw if string transition is not defined', () => {
+    assert.throws(() => lightMachine.transition('red', 'BAD_COND'));
+  });
+});
+
+describe('guard conditions', () => {
+  const machine = Machine({
+    key: 'microsteps',
+    parallel: true,
+    states: {
+      A: {
+        initial: 'A0',
+        states: {
+          A0: {
+            on: {
+              A: 'A1'
+            }
+          },
+          A1: {
+            on: {
+              A: 'A2'
+            }
+          },
+          A2: {
+            on: {
+              A: 'A3'
+            }
+          },
+          A3: {
+            on: {
+              '': 'A4'
+            }
+          },
+          A4: {
+            on: {
+              '': 'A5'
+            }
+          },
+          A5: {}
+        }
+      },
+      B: {
+        initial: 'B0',
+        states: {
+          B0: {
+            on: {
+              T1: [
+                {
+                  target: 'B1',
+                  cond: (_state, _event, interim) =>
+                    matchesState('A.A1', interim)
+                }
+              ],
+              T2: [
+                {
+                  target: 'B2',
+                  cond: (_state, _event, interim) =>
+                    matchesState('A.A2', interim)
+                }
+              ],
+              T3: [
+                {
+                  target: 'B3',
+                  cond: (_state, _event, interim) =>
+                    matchesState('A.A3', interim)
+                }
+              ],
+              '': [
+                {
+                  target: 'B4',
+                  cond: (_state, _event, interim) =>
+                    matchesState('A.A4', interim)
+                }
+              ]
+            }
+          },
+          B1: {},
+          B2: {},
+          B3: {},
+          B4: {}
+        }
+      }
+    }
+  });
+
+  it('should guard against transition', () => {
+    assert.deepEqual(machine.transition({ A: 'A2', B: 'B0' }, 'T1').value, {
+      A: 'A2',
+      B: 'B0'
+    });
+  });
+
+  it('should allow a matching transition', () => {
+    assert.deepEqual(machine.transition({ A: 'A2', B: 'B0' }, 'T2').value, {
+      A: 'A2',
+      B: 'B2'
+    });
+  });
+
+  it('should check guards with interim states', () => {
+    assert.deepEqual(machine.transition({ A: 'A2', B: 'B0' }, 'A').value, {
+      A: 'A5',
+      B: 'B4'
+    });
+  });
 });