xstate 3.3.2 → 3.3.3

package/src/scxml.ts

@@ -62,26 +62,54 @@ function stateNodeToSCXML(stateNode: StateNode) {
         return stateNodeToSCXML(subStateNode);
       }),
       ...Object.keys(stateNode.on)
-        .map((event): XMLElement[] => {
-          const transition = stateNode.on![event];
+        .map(
+          (event): XMLElement[] => {
+            const transition = stateNode.on![event];
 
-          if (!transition) {
-            return [];
-          }
+            if (!transition) {
+              return [];
+            }
+
+            if (Array.isArray(transition)) {
+              return transition.map(targetTransition => {
+                return {
+                  type: 'element',
+                  name: 'transition',
+                  attributes: {
+                    ...(event ? { event } : undefined),
+                    target: stateNode.parent!.getRelativeStateNodes(
+                      targetTransition.target
+                    )[0]!.id, // TODO: fixme
+                    ...(targetTransition.cond
+                      ? { cond: targetTransition.cond.toString() }
+                      : undefined)
+                  },
+                  elements: targetTransition.actions
+                    ? targetTransition.actions.map(action => ({
+                        type: 'element',
+                        name: 'send',
+                        attributes: {
+                          event: getActionType(action)
+                        }
+                      }))
+                    : undefined
+                };
+              });
+            }
+
+            return Object.keys(transition).map(target => {
+              const targetTransition = transition[target];
 
-          if (Array.isArray(transition)) {
-            return transition.map(targetTransition => {
               return {
                 type: 'element',
                 name: 'transition',
                 attributes: {
-                  ...event ? { event } : undefined,
-                  target: stateNode.parent!.getRelativeStateNodes(
-                    targetTransition.target
-                  )[0]!.id, // TODO: fixme
-                  ...targetTransition.cond
+                  ...(event ? { event } : undefined),
+                  target: stateNode.parent!.getRelativeStateNodes(target)![0]
+                    .id, // TODO: fixme
+                  ...(targetTransition.cond
                     ? { cond: targetTransition.cond.toString() }
-                    : undefined
+                    : undefined)
                 },
                 elements: targetTransition.actions
                   ? targetTransition.actions.map(action => ({
@@ -95,32 +123,7 @@ function stateNodeToSCXML(stateNode: StateNode) {
               };
             });
           }
-
-          return Object.keys(transition).map(target => {
-            const targetTransition = transition[target];
-
-            return {
-              type: 'element',
-              name: 'transition',
-              attributes: {
-                ...event ? { event } : undefined,
-                target: stateNode.parent!.getRelativeStateNodes(target)![0].id, // TODO: fixme
-                ...targetTransition.cond
-                  ? { cond: targetTransition.cond.toString() }
-                  : undefined
-              },
-              elements: targetTransition.actions
-                ? targetTransition.actions.map(action => ({
-                    type: 'element',
-                    name: 'send',
-                    attributes: {
-                      event: getActionType(action)
-                    }
-                  }))
-                : undefined
-            };
-          });
-        })
+        )
         .reduce((a, b) => a.concat(b))
     ].filter(Boolean) as XMLElement[]
   };
@@ -276,12 +279,12 @@ function toConfig(
       (values: XMLElement[]) => {
         return values.map(value => ({
           target: `#${value.attributes!.target}`,
-          ...value.elements ? executableContent(value.elements) : undefined,
-          ...value.attributes!.cond
+          ...(value.elements ? executableContent(value.elements) : undefined),
+          ...(value.attributes!.cond
             ? {
                 cond: evalCond(value.attributes!.cond as string)
               }
-            : undefined
+            : undefined)
         }));
       }
     );
@@ -311,18 +314,18 @@ function toConfig(
     return {
       id,
       delimiter: options.delimiter,
-      ...initial ? { initial } : undefined,
-      ...parallel ? { parallel } : undefined,
-      ...stateElements.length
+      ...(initial ? { initial } : undefined),
+      ...(parallel ? { parallel } : undefined),
+      ...(stateElements.length
         ? {
             states: mapValues(states, (state, key) =>
               toConfig(state, key, options)
             )
           }
-        : undefined,
-      ...transitionElements.length ? { on } : undefined,
-      ...onEntry ? { onEntry } : undefined,
-      ...onExit ? { onExit } : undefined
+        : undefined),
+      ...(transitionElements.length ? { on } : undefined),
+      ...(onEntry ? { onEntry } : undefined),
+      ...(onExit ? { onExit } : undefined)
     };
   }
 

package/src/types.ts

@@ -25,6 +25,11 @@ export interface StateValueMap {
 
 export type StateValue = string | StateValueMap;
 
+export interface HistoryValue {
+  states: Record<string, HistoryValue | undefined>;
+  current: StateValue | undefined;
+}
+
 export type ConditionPredicate = (
   extendedState: any,
   event: EventObject,
@@ -112,7 +117,6 @@ export interface StandardMachineConfig extends MachineConfig {
 export interface ParallelMachineConfig extends MachineConfig {
   initial?: undefined;
   parallel: true;
-  states: Record<string, CompoundStateNodeConfig>;
 }
 
 export interface EntryExitEffectMap {
@@ -190,15 +194,8 @@ export type MaybeStateValueActionsTuple = [
   ActivityMap | undefined
 ];
 
-export interface StateTransition {
-  statePaths: string[][];
-  actions: ActionMap;
-  activities: ActivityMap | undefined;
-  events: EventObject[];
-}
-
 // tslint:disable-next-line:class-name
-export interface _StateTransition {
+export interface StateTransition {
   value: StateValue | undefined;
   entryExitStates: EntryExitStates | undefined;
   actions: Action[];

package/src/utils.ts

@@ -16,7 +16,9 @@ export function getActionType(action: Action): ActionType {
   try {
     return typeof action === 'string' || typeof action === 'number'
       ? `${action}`
-      : typeof action === 'function' ? action.name : action.type;
+      : typeof action === 'function'
+        ? action.name
+        : action.type;
   } catch (e) {
     throw new Error(
       'Events must be strings or objects with a string event.type property.'
@@ -113,18 +115,37 @@ export function mapFilterValues<T, P>(
  * Retrieves a value at the given path.
  * @param props The deep path to the prop of the desired value
  */
-export const path = (props: string[]): any => <T extends Record<string, any>>(
+export const path = <T extends Record<string, any>>(props: string[]): any => (
   object: T
 ): any => {
-  let result: Record<string, any> = object;
+  let result: T = object;
 
   for (const prop of props) {
-    result = result[prop];
+    result = result[prop as keyof typeof result];
   }
 
   return result;
 };
 
+/**
+ * Retrieves a value at the given path via the nested accessor prop.
+ * @param props The deep path to the prop of the desired value
+ */
+export function nestedPath<T extends Record<string, any>>(
+  props: string[],
+  accessorProp: keyof T
+): (object: T) => T {
+  return object => {
+    let result: T = object;
+
+    for (const prop of props) {
+      result = result[accessorProp][prop];
+    }
+
+    return result;
+  };
+}
+
 export const toStatePaths = (stateValue: StateValue): string[][] => {
   if (typeof stateValue === 'string') {
     return [[stateValue]];

package/test/activities.test.ts

@@ -203,6 +203,21 @@ describe('transient activities', () => {
           B1: '.B1',
           B2: '.B2'
         }
+      },
+      C: {
+        initial: 'C1',
+        states: {
+          C1: {
+            activities: ['C1'],
+            on: {
+              C: 'C1',
+              C_SIMILAR: 'C2'
+            }
+          },
+          C2: {
+            activities: ['C1'],
+          },
+        }
       }
     }
   });
@@ -223,10 +238,22 @@ describe('transient activities', () => {
     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' });
+    assert.deepEqual(state.value, { A: 'A2', B: 'B2', C: 'C1' });
     assert.deepEqual(state.activities.B2, true);
   });
 });

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 = {

package/test/history.test.ts

@@ -301,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'));
+  });
+});