Switch to resolveState method

statelyai · Nov 10, 2023 · 210beb0 · 210beb0
1 parent a299b3e
commit 210beb0
Show file tree

Hide file tree

Showing 11 changed files with 52 additions and 43 deletions.
diff --git a/packages/core/src/StateMachine.ts b/packages/core/src/StateMachine.ts
@@ -46,7 +46,8 @@ import type {
   TODO,
   SnapshotFrom,
   Snapshot,
-  AnyActorLogic
+  AnyActorLogic,
+  HistoryValue
 } from './types.ts';
 import { isErrorActorEvent, resolveReferencedActor } from './utils.ts';
 import { $$ACTOR_TYPE, createActor } from './interpreter.ts';
@@ -248,11 +249,17 @@ export class StateMachine<
     });
   }
 
-  public resolveStateValue(
-    stateValue: StateValue,
-    ...[context]: Equals<TContext, MachineContext> extends true
-      ? []
-      : [TContext]
+  public resolveState(
+    config: {
+      value: StateValue;
+      context?: TContext;
+      historyValue?: HistoryValue<TContext, TEvent>;
+      status?: 'active' | 'done' | 'error' | 'stopped';
+      output?: TOutput;
+      error?: unknown;
+    } & (Equals<TContext, MachineContext> extends false
+      ? { context: unknown }
+      : {})
   ): MachineSnapshot<
     TContext,
     TEvent,
@@ -261,17 +268,22 @@ export class StateMachine<
     TOutput,
     TResolvedTypesMeta
   > {
-    const resolvedStateValue = resolveStateValue(this.root, stateValue);
+    const resolvedStateValue = resolveStateValue(this.root, config.value);
     const configurationSet = getConfiguration(
       getStateNodes(this.root, resolvedStateValue)
     );
 
     return new State(
       {
         configuration: [...configurationSet],
-        context: (context || {}) as TContext,
+        context: config.context || ({} as TContext),
         children: {},
-        status: isInFinalState(configurationSet, this.root) ? 'done' : 'active'
+        status: isInFinalState(configurationSet, this.root)
+          ? 'done'
+          : config.status || 'active',
+        output: config.output,
+        error: config.error,
+        historyValue: config.historyValue
       },
       this
     ) as MachineSnapshot<
@@ -386,7 +398,6 @@ export class StateMachine<
       {
         context:
           typeof context !== 'function' && context ? context : ({} as TContext),
-        meta: undefined,
         configuration: getInitialConfiguration(this.root),
         children: {},
         status: 'active'

diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
@@ -1657,13 +1657,11 @@ export interface StateConfig<
 > {
   context: TContext;
   historyValue?: HistoryValue<TContext, TEvent>;
-  meta?: any;
   configuration: Array<StateNode<TContext, TEvent>>;
   children: Record<string, ActorRef<any, any>>;
   status: 'active' | 'done' | 'error' | 'stopped';
   output?: any;
   error?: unknown;
-  tags?: Set<string>;
   machine?: StateMachine<TContext, TEvent, any, any, any, any, any, any, any>;
 }
 

diff --git a/packages/core/test/deterministic.test.ts b/packages/core/test/deterministic.test.ts
@@ -66,7 +66,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(
         lightMachine.transition(
-          lightMachine.resolveStateValue('green'),
+          lightMachine.resolveState({ value: 'green' }),
           {
             type: 'TIMER'
           },
@@ -102,7 +102,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(() =>
         lightMachine.transition(
-          testMachine.resolveStateValue('red'),
+          testMachine.resolveState({ value: 'red' }),
           undefined as any,
           actorScope
         )
@@ -113,7 +113,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(
         testMachine.transition(
-          testMachine.resolveStateValue('a'),
+          testMachine.resolveState({ value: 'a' }),
           { type: 'T' },
           actorScope
         ).value
@@ -126,7 +126,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(() =>
         testMachine.transition(
-          testMachine.resolveStateValue('fake'),
+          testMachine.resolveState({ value: 'fake' }),
           { type: 'T' },
           actorScope
         )
@@ -137,7 +137,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(() =>
         testMachine.transition(
-          testMachine.resolveStateValue('a.fake'),
+          testMachine.resolveState({ value: 'a.fake' }),
           {
             type: 'T'
           },
@@ -175,7 +175,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(
         lightMachine.transition(
-          lightMachine.resolveStateValue({ red: 'walk' }),
+          lightMachine.resolveState({ value: { red: 'walk' } }),
           { type: 'PED_COUNTDOWN' },
           actorScope
         ).value
@@ -186,7 +186,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(
         lightMachine.transition(
-          lightMachine.resolveStateValue('red'),
+          lightMachine.resolveState({ value: 'red' }),
           {
             type: 'PED_COUNTDOWN'
           },
@@ -201,7 +201,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(
         lightMachine.transition(
-          lightMachine.resolveStateValue('red'),
+          lightMachine.resolveState({ value: 'red' }),
           {
             type: 'PED_COUNTDOWN'
           },
@@ -216,7 +216,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(
         lightMachine.transition(
-          lightMachine.resolveStateValue({ red: 'stop' }),
+          lightMachine.resolveState({ value: { red: 'stop' } }),
           { type: 'TIMER' },
           actorScope
         ).value
@@ -255,7 +255,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
       expect(
         lightMachine.transition(
-          lightMachine.resolveStateValue('yellow'),
+          lightMachine.resolveState({ value: 'yellow' }),
           {
             type: 'TIMER'
           },
@@ -327,7 +327,7 @@ describe('deterministic machine', () => {
       const actorScope = null as any; // TODO: figure out the simulation API
 
       const walkState = lightMachine.transition(
-        lightMachine.resolveStateValue({ red: 'walk' }),
+        lightMachine.resolveState({ value: { red: 'walk' } }),
         { type: 'TIMER' },
         actorScope
       );

diff --git a/packages/core/test/interpreter.test.ts b/packages/core/test/interpreter.test.ts
@@ -1054,7 +1054,7 @@ describe('interpreter', () => {
         }
       });
       const actor = createActor(machine, {
-        state: machine.resolveStateValue('bar')
+        state: machine.resolveState({ value: 'bar' })
       });
 
       expect(actor.getSnapshot().matches('bar')).toBeTruthy();
@@ -1071,7 +1071,7 @@ describe('interpreter', () => {
         }
       });
       const actor = createActor(machine, {
-        state: machine.resolveStateValue('bar')
+        state: machine.resolveState({ value: 'bar' })
       });
 
       expect(actor.getSnapshot().matches('bar')).toBeTruthy();
@@ -1094,7 +1094,7 @@ describe('interpreter', () => {
         }
       });
       const actor = createActor(machine, {
-        state: machine.resolveStateValue('foo')
+        state: machine.resolveState({ value: 'foo' })
       });
 
       expect(actor.getSnapshot().matches({ foo: 'one' })).toBeTruthy();

diff --git a/packages/core/test/invalid.test.ts b/packages/core/test/invalid.test.ts
@@ -23,7 +23,7 @@ describe('invalid or resolved states', () => {
     });
     expect(
       machine.transition(
-        machine.resolveStateValue('A'),
+        machine.resolveState({ value: 'A' }),
         { type: 'E' },
         {} as any // TODO: figure out the simulation API
       ).value
@@ -55,7 +55,7 @@ describe('invalid or resolved states', () => {
     });
     expect(
       machine.transition(
-        machine.resolveStateValue({ A: {}, B: {} }),
+        machine.resolveState({ value: { A: {}, B: {} } }),
         { type: 'E' },
         {} as any // TODO: figure out the simulation API
       ).value
@@ -86,7 +86,7 @@ describe('invalid or resolved states', () => {
       }
     });
     machine.transition(
-      machine.resolveStateValue({ A: 'A1', B: 'B1' }),
+      machine.resolveState({ value: { A: 'A1', B: 'B1' } }),
       { type: 'E' },
       {} as any // TODO: figure out the simulation API
     );
@@ -114,7 +114,7 @@ describe('invalid or resolved states', () => {
     });
     expect(() =>
       machine.transition(
-        machine.resolveStateValue({ A: 'A3', B: 'B3' }),
+        machine.resolveState({ value: { A: 'A3', B: 'B3' } }),
         { type: 'E' },
         {} as any // TODO: figure out the simulation API
       )
@@ -143,7 +143,7 @@ describe('invalid or resolved states', () => {
     });
     expect(
       machine.transition(
-        machine.resolveStateValue({ A: 'A1', B: {} }),
+        machine.resolveState({ value: { A: 'A1', B: {} } }),
         { type: 'E' },
         {} as any // TODO: figure out the simulation API
       ).value

diff --git a/packages/core/test/machine.test.ts b/packages/core/test/machine.test.ts
@@ -283,15 +283,15 @@ describe('machine', () => {
     });
 
     it('should resolve the state value', () => {
-      const resolvedState = resolveMachine.resolveStateValue('foo');
+      const resolvedState = resolveMachine.resolveState({ value: 'foo' });
 
       expect(resolvedState.value).toEqual({
         foo: { one: { a: 'aa', b: 'bb' } }
       });
     });
 
     it('should resolve the state configuration (implicit via events)', () => {
-      const resolvedState = resolveMachine.resolveStateValue('foo');
+      const resolvedState = resolveMachine.resolveState({ value: 'foo' });
 
       expect(resolvedState.nextEvents.sort()).toEqual(['TO_BAR', 'TO_TWO']);
     });
@@ -309,7 +309,7 @@ describe('machine', () => {
         }
       });
 
-      const resolvedState = machine.resolveStateValue('bar');
+      const resolvedState = machine.resolveState({ value: 'bar' });
 
       expect(resolvedState.status).toBe('done');
     });

diff --git a/packages/core/test/meta.test.ts b/packages/core/test/meta.test.ts
@@ -125,7 +125,7 @@ describe('state meta data', () => {
     });
 
     const actor = createActor(machine, {
-      state: machine.resolveStateValue('second')
+      state: machine.resolveState({ value: 'second' })
     });
     actor.start();
 

diff --git a/packages/core/test/microstep.test.ts b/packages/core/test/microstep.test.ts
@@ -58,7 +58,7 @@ describe('machine.microstep()', () => {
 
     const actorScope = null as any; // TODO: figure out the simulation API
     const states = machine.microstep(
-      machine.resolveStateValue('first'),
+      machine.resolveState({ value: 'first' }),
       { type: 'TRIGGER' },
       actorScope
     );
@@ -89,7 +89,7 @@ describe('machine.microstep()', () => {
 
     const actorScope = null as any; // TODO: figure out the simulation API
     const states = machine.microstep(
-      machine.resolveStateValue('first'),
+      machine.resolveState({ value: 'first' }),
       { type: 'TRIGGER' },
       actorScope
     );

diff --git a/packages/core/test/rehydration.test.ts b/packages/core/test/rehydration.test.ts
@@ -81,7 +81,7 @@ describe('rehydration', () => {
         }
       });
 
-      const activeState = machine.resolveStateValue('active');
+      const activeState = machine.resolveState({ value: 'active' });
       const service = createActor(machine, {
         state: activeState
       });
@@ -107,7 +107,7 @@ describe('rehydration', () => {
       });
 
       createActor(machine, {
-        state: machine.resolveStateValue('active')
+        state: machine.resolveState({ value: 'active' })
       })
         .start()
         .stop();

diff --git a/packages/core/test/utils.ts b/packages/core/test/utils.ts
@@ -11,8 +11,8 @@ const resolveSerializedStateValue = (
   serialized: string
 ) =>
   serialized[0] === '{'
-    ? machine.resolveStateValue(JSON.parse(serialized), {})
-    : machine.resolveStateValue(serialized, {});
+    ? machine.resolveState({ value: JSON.parse(serialized), context: {} })
+    : machine.resolveState({ value: serialized, context: {} });
 
 export function testMultiTransition(
   machine: AnyStateMachine,

diff --git a/packages/xstate-graph/test/graph.test.ts b/packages/xstate-graph/test/graph.test.ts
@@ -477,7 +477,7 @@ describe('@xstate/graph', () => {
 
     it('should return a path from a specified from-state', () => {
       const path = getPathsFromEvents(lightMachine, [{ type: 'TIMER' }], {
-        fromState: lightMachine.resolveStateValue('yellow')
+        fromState: lightMachine.resolveState({ value: 'yellow' })
       })[0];
 
       expect(path).toBeDefined();
@@ -655,7 +655,7 @@ it.each([getShortestPaths, getSimplePaths])(
     });
 
     const paths = pathGetter(machine, {
-      fromState: machine.resolveStateValue('b')
+      fromState: machine.resolveState({ value: 'b' })
     });
 
     // Instead of taking 2 steps to reach state 'b' (A, B),