xstate 3.2.1 → 3.3.3

package/test/history.test.ts

@@ -7,7 +7,7 @@ describe('history states', () => {
     initial: 'off',
     states: {
       off: {
-        on: { POWER: 'on.$history' }
+        on: { POWER: 'on.$history', H_POWER: 'on.H' }
       },
       on: {
         initial: 'first',
@@ -18,10 +18,14 @@ describe('history states', () => {
           second: {
             on: { SWITCH: 'third' }
           },
-          third: {}
+          third: {},
+          H: {
+            history: true
+          }
         },
         on: {
-          POWER: 'off'
+          POWER: 'off',
+          H_POWER: 'off'
         }
       }
     }
@@ -37,12 +41,36 @@ describe('history states', () => {
     );
   });
 
+  it('should go to the most recently visited state (explicit)', () => {
+    const onSecondState = historyMachine.transition('on', 'SWITCH');
+    const offState = historyMachine.transition(onSecondState, 'H_POWER');
+
+    assert.equal(
+      historyMachine.transition(offState, 'H_POWER').toString(),
+      'on.second'
+    );
+  });
+
   it('should go to the initial state when no history present', () => {
     assert.equal(
       historyMachine.transition('off', 'POWER').toString(),
       'on.first'
     );
   });
+
+  it('should go to the initial state when no history present (explicit)', () => {
+    assert.equal(
+      historyMachine.transition('off', 'H_POWER').toString(),
+      'on.first'
+    );
+  });
+
+  it('should dispose of previous histories', () => {
+    const onSecondState = historyMachine.transition('on', 'SWITCH');
+    const offState = historyMachine.transition(onSecondState, 'H_POWER');
+    const nextState = historyMachine.transition(offState, 'H_POWER');
+    assert.isUndefined(nextState.history!.history);
+  });
 });
 
 describe('deep history states', () => {
@@ -53,8 +81,7 @@ describe('deep history states', () => {
       off: {
         on: {
           POWER: 'on.$history',
-          DEEP_POWER: 'on.$history.$history',
-          DEEPEST_POWER: 'on.$history.$history.$history'
+          DEEP_POWER: 'on.deepHistory'
         }
       },
       on: {
@@ -79,6 +106,9 @@ describe('deep history states', () => {
                 }
               }
             }
+          },
+          deepHistory: {
+            history: 'deep'
           }
         },
         on: {
@@ -104,7 +134,8 @@ describe('deep history states', () => {
         'on.second.A'
       );
     });
-    it('should go to the deep history', () => {
+
+    it('should go to the deep history (explicit)', () => {
       // on.second.B.P -> off
       const stateOff = historyMachine.transition(state2BP, 'POWER');
       assert.equal(
@@ -112,21 +143,15 @@ describe('deep history states', () => {
         'on.second.B.P'
       );
     });
+
     it('should go to the deepest history', () => {
       // on.second.B.Q -> off
       const stateOff = historyMachine.transition(state2BQ, 'POWER');
       assert.equal(
-        historyMachine.transition(stateOff, 'DEEPEST_POWER').toString(),
+        historyMachine.transition(stateOff, 'DEEP_POWER').toString(),
         'on.second.B.Q'
       );
     });
-    it('can go to the shallow histor even when $history.$history is used', () => {
-      const stateOff = historyMachine.transition(state2A, 'POWER');
-      assert.equal(
-        historyMachine.transition(stateOff, 'DEEPEST_POWER').toString(),
-        'on.second.A'
-      );
-    });
   });
 });
 
@@ -139,12 +164,11 @@ describe('parallel history states', () => {
         on: {
           SWITCH: 'on', // go to the initial states
           POWER: 'on.$history',
-          DEEP_POWER: 'on.$history.$history',
-          DEEPEST_POWER: 'on.$history.$history.$history',
+          DEEP_POWER: 'on.deepHistory',
           PARALLEL_HISTORY: [{ target: ['on.A.$history', 'on.K.$history'] }],
           PARALLEL_SOME_HISTORY: [{ target: ['on.A.C', 'on.K.$history'] }],
           PARALLEL_DEEP_HISTORY: [
-            { target: ['on.A.$history.$history', 'on.K.$history.$history'] }
+            { target: ['on.A.deepHistory', 'on.K.deepHistory'] }
           ]
         }
       },
@@ -165,6 +189,9 @@ describe('parallel history states', () => {
                   },
                   E: {}
                 }
+              },
+              deepHistory: {
+                history: 'deep'
               }
             }
           },
@@ -182,8 +209,17 @@ describe('parallel history states', () => {
                   },
                   O: {}
                 }
+              },
+              deepHistory: {
+                history: 'deep'
               }
             }
+          },
+          shallowHistory: {
+            history: 'shallow'
+          },
+          deepHistory: {
+            history: 'deep'
           }
         },
         on: {
@@ -224,50 +260,10 @@ describe('parallel history states', () => {
       );
     });
 
-    it('should remember second level state history', () => {
-      const stateOff = historyMachine.transition(stateACDKL, 'POWER');
-      assert.deepEqual(
-        historyMachine.transition(stateOff, 'DEEPEST_POWER').value,
-        {
-          on: { A: { C: 'D' }, K: 'L' }
-        }
-      );
-    });
-
-    it('should remember second level state history, ignoring too many levels of $history', () => {
-      const stateOff = historyMachine.transition(stateACDKL, 'POWER');
-      assert.deepEqual(
-        historyMachine.transition(stateOff, 'DEEPEST_POWER').value,
-        {
-          on: { A: { C: 'D' }, K: 'L' }
-        }
-      );
-    });
-
-    it('should remember three levels of state history', () => {
-      const stateOff = historyMachine.transition(stateACEKL, 'POWER');
-      assert.deepEqual(
-        historyMachine.transition(stateOff, 'DEEPEST_POWER').value,
-        {
-          on: { A: { C: 'E' }, K: 'L' }
-        }
-      );
-    });
-
-    xit('should re-enter each regions of parallel state correctly', () => {
+    it('should re-enter each regions of parallel state correctly', () => {
       const stateOff = historyMachine.transition(stateACEKMO, 'POWER');
       assert.deepEqual(
         historyMachine.transition(stateOff, 'DEEP_POWER').value,
-        {
-          on: { A: { C: 'D' }, K: { M: 'N' } }
-        }
-      );
-    });
-
-    xit('should retain all regions of parallel state', () => {
-      const stateOff = historyMachine.transition(stateACEKMO, 'POWER');
-      assert.deepEqual(
-        historyMachine.transition(stateOff, 'DEEPEST_POWER').value,
         {
           on: { A: { C: 'E' }, K: { M: 'O' } }
         }
@@ -305,3 +301,142 @@ describe('parallel history states', () => {
     });
   });
 });
+
+describe('transient history', () => {
+  const transientMachine = Machine({
+    initial: 'A',
+    parallel: false,
+    states: {
+      A: {
+        on: { EVENT: 'B' }
+      },
+      B: {
+        on: {
+          // eventless transition
+          '': 'C'
+        }
+      },
+      C: {}
+    }
+  });
+  it('should have history on transient transitions', () => {
+    const nextState = transientMachine.transition('A', 'EVENT');
+    assert.equal(nextState.value, 'C');
+    assert.isDefined(nextState.history);
+  });
+});
+
+describe('internal transition with history', () => {
+  const machine = Machine({
+    key: 'test',
+    initial: 'first',
+    states: {
+      first: {
+        initial: 'foo',
+        states: {
+          foo: {}
+        },
+        on: {
+          NEXT: 'second.other'
+        }
+      },
+      second: {
+        initial: 'nested',
+        states: {
+          nested: {},
+          other: {},
+          hist: {
+            history: true
+          }
+        },
+        on: {
+          NEXT: [
+            {
+              target: '.hist'
+            }
+          ]
+        }
+      }
+    }
+  });
+
+  it('should transition internally to the most recently visited state', () => {
+    // {
+    //   $current: 'first',
+    //   first: undefined,
+    //   second: {
+    //     $current: 'nested',
+    //     nested: undefined,
+    //     other: undefined
+    //   }
+    // }
+    const state2 = machine.transition(machine.initialState, 'NEXT');
+    // {
+    //   $current: 'second',
+    //   first: undefined,
+    //   second: {
+    //     $current: 'other',
+    //     nested: undefined,
+    //     other: undefined
+    //   }
+    // }
+    const state3 = machine.transition(state2, 'NEXT');
+    // {
+    //   $current: 'second',
+    //   first: undefined,
+    //   second: {
+    //     $current: 'other',
+    //     nested: undefined,
+    //     other: undefined
+    //   }
+    // }
+
+    assert.deepEqual(state3.value, { second: 'other' });
+  });
+});
+
+describe('multistage history states', () => {
+  const pcWithTurboButtonMachine = Machine({
+    key: 'pc-with-turbo-button',
+    initial: 'off',
+    states: {
+      off: {
+        on: { POWER: 'starting' }
+      },
+      starting: {
+        on: { STARTED: 'running.H' }
+      },
+      running: {
+        initial: 'normal',
+        states: {
+          normal: {
+            on: { SWITCH_TURBO: 'turbo' }
+          },
+          turbo: {
+            on: { SWITCH_TURBO: 'normal' }
+          },
+          H: {
+            history: true
+          }
+        },
+        on: {
+          POWER: 'off'
+        }
+      }
+    }
+  });
+
+  it('should go to the most recently visited state', () => {
+    const onTurboState = pcWithTurboButtonMachine.transition(
+      'running',
+      'SWITCH_TURBO'
+    );
+    const offState = pcWithTurboButtonMachine.transition(onTurboState, 'POWER');
+    const loadingState = pcWithTurboButtonMachine.transition(offState, 'POWER');
+
+    assert.equal(
+      pcWithTurboButtonMachine.transition(loadingState, 'STARTED').toString(),
+      'running.turbo'
+    );
+  });
+});

package/test/invalid.test.ts

@@ -0,0 +1,48 @@
+import { assert } from 'chai';
+import { Machine } from '../src/index';
+
+const machine = Machine({
+  parallel: true,
+  states: {
+    A: {
+      initial: 'A1',
+      states: {
+        A1: {},
+        A2: {}
+      }
+    },
+    B: {
+      initial: 'B1',
+      states: {
+        B1: {},
+        B2: {}
+      }
+    }
+  }
+});
+
+describe('invalid states', () => {
+  xit('should reject transitioning from a String state', () => {
+    assert.throws(() => machine.transition('A', 'E'));
+  });
+
+  xit('should reject transitioning from empty states', () => {
+    assert.throws(() => machine.transition({ A: {}, B: {} }, 'E'));
+  });
+
+  it('should allow transitioning from valid states', () => {
+    machine.transition({ A: 'A1', B: 'B1' }, 'E');
+  });
+
+  it('should reject transitioning from bad state configs', () => {
+    assert.throws(() => machine.transition({ A: 'A3', B: 'B3' }, 'E'));
+  });
+
+  xit('should reject transitioning from partially valid states', () => {
+    assert.throws(() => machine.transition({ A: 'A1' }, 'E'));
+  });
+
+  xit("should reject transitioning from regions that don't exist", () => {
+    assert.throws(() => machine.transition({ A: 'A1', B: 'B1', Z: 'Z1' }, 'E'));
+  });
+});

package/test/multiple.test.ts

@@ -163,44 +163,38 @@ describe('multiple', () => {
     });
 
     it('should reject two targets in the same region', () => {
-      assert.throws(
-        () => machine.transition(stateSimple, 'BROKEN_SAME_REGION'),
-        "Event 'BROKEN_SAME_REGION' on state 'machine.simple' leads to an invalid configuration: Two or more states in the orthogonal region 'machine.para.A'"
+      assert.throws(() =>
+        machine.transition(stateSimple, 'BROKEN_SAME_REGION')
       );
     });
 
     it('should reject targets inside and outside a region', () => {
-      assert.throws(
-        () => machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS'),
-        "Event 'BROKEN_DIFFERENT_REGIONS' on state 'machine.simple' leads to an invalid configuration: Two or more states in the orthogonal region 'machine'"
+      assert.throws(() =>
+        machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS')
       );
     });
 
     it('should reject two targets in different regions', () => {
-      assert.throws(
-        () => machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS_2'),
-        "Event 'BROKEN_DIFFERENT_REGIONS_2' on state 'machine.simple' leads to an invalid configuration: Two or more states in the orthogonal region 'machine'"
+      assert.throws(() =>
+        machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS_2')
       );
     });
 
     it('should reject two targets in different regions at different levels', () => {
-      assert.throws(
-        () => machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS_3'),
-        "Event 'BROKEN_DIFFERENT_REGIONS_3' on state 'machine.simple' leads to an invalid configuration: Two or more states in the orthogonal region 'machine'"
+      assert.throws(() =>
+        machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS_3')
       );
     });
 
     it('should reject two deep targets in different regions at top level', () => {
-      assert.throws(
-        () => machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS_3'),
-        "Event 'BROKEN_DIFFERENT_REGIONS_3' on state 'machine.simple' leads to an invalid configuration: Two or more states in the orthogonal region 'machine'"
+      assert.throws(() =>
+        machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS_3')
       );
     });
 
     it('should reject two deep targets in different regions at different levels', () => {
-      assert.throws(
-        () => machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS_4'),
-        "Event 'BROKEN_DIFFERENT_REGIONS_4' on state 'machine.simple' leads to an invalid configuration: Two or more states in the orthogonal region 'machine.para2.K2'"
+      assert.throws(() =>
+        machine.transition(stateSimple, 'BROKEN_DIFFERENT_REGIONS_4')
       );
     });
   });