xstate 6.0.0-alpha.12 → 6.0.0-alpha.13

package/dist/xstate.cjs.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dist_xstateActors = require('./index-698a3320.cjs.js');
-var StateMachine = require('./StateMachine-7af634f9.cjs.js');
+var dist_xstateActors = require('./index-32631949.cjs.js');
+var StateMachine = require('./StateMachine-1b26c5de.cjs.js');
 
 /**
  * Asserts that the given event object is of the specified type or types. Throws
@@ -91,6 +91,339 @@ function createStateConfig(config) {
   return config;
 }
 
+const emptyImplementations = {
+  actions: {},
+  actorSources: {},
+  guards: {},
+  delays: {}
+};
+const emptyExecutableActions = [];
+const emptyRawActions = [];
+const builtInActionSet = new Set(Object.values(dist_xstateActors.builtInActions));
+function toArray(value) {
+  return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}
+function resolveContext(context, input) {
+  return typeof context === 'function' ? context({
+    input
+  }) : context ?? {};
+}
+function resolveTransitionContext(context, args) {
+  return typeof context === 'function' ? context(args) : context;
+}
+function resolveInput(input, context, event) {
+  return typeof input === 'function' ? input({
+    context,
+    event
+  }) : input;
+}
+function mergeContextPatch(context, patch) {
+  for (const key of Object.keys(patch)) {
+    if (!Object.prototype.hasOwnProperty.call(context, key) || !Object.is(context[key], patch[key])) {
+      return {
+        ...context,
+        ...patch
+      };
+    }
+  }
+  return context;
+}
+function createSnapshot(value, context, input, machine, stateInput) {
+  return {
+    status: 'active',
+    output: undefined,
+    error: undefined,
+    value,
+    context,
+    input,
+    children: {},
+    _stateInput: stateInput,
+    machine
+  };
+}
+function cloneSnapshot(snapshot, value, context, stateInput) {
+  return {
+    status: snapshot.status,
+    output: snapshot.output,
+    error: snapshot.error,
+    value,
+    context,
+    input: snapshot.input,
+    children: snapshot.children,
+    _stateInput: stateInput,
+    machine: snapshot.machine
+  };
+}
+function stopSnapshot(snapshot) {
+  return {
+    status: 'stopped',
+    output: undefined,
+    error: undefined,
+    value: snapshot.value,
+    context: snapshot.context,
+    input: undefined,
+    children: snapshot.children,
+    _stateInput: snapshot._stateInput,
+    machine: snapshot.machine
+  };
+}
+function assertNoStringTransitions(config) {
+  for (const [stateKey, stateConfig] of Object.entries(config.states)) {
+    for (const [eventType, transitionConfig] of Object.entries(stateConfig.on ?? {})) {
+      for (const transition of toArray(transitionConfig)) {
+        if (typeof transition === 'string') {
+          const target = transition;
+          throw new Error(`Invalid transition for "${stateKey}.${eventType}": use { target: "${target}" } instead of a string target.`);
+        }
+      }
+    }
+  }
+}
+function resolveSimpleEnqueuedActions(rawActions) {
+  const executableActions = [];
+  for (const action of rawActions) {
+    if (!action || typeof action !== 'object' || !('action' in action) || typeof action.action !== 'function' || builtInActionSet.has(action.action) || '_special' in action.action) {
+      return undefined;
+    }
+    executableActions.push({
+      type: action.action.name || '(anonymous)',
+      params: undefined,
+      args: action.args,
+      exec: action.args.length ? action.action.bind(null, ...action.args) : action.action
+    });
+  }
+  return executableActions;
+}
+function createFSM(config) {
+  const machine = {
+    id: config.id ?? '(fsm)',
+    implementations: emptyImplementations
+  };
+  assertNoStringTransitions(config);
+  const runActions = (snapshot, event, actorScope, rawActions) => {
+    if (!rawActions?.length) {
+      return [snapshot, emptyExecutableActions];
+    }
+    const simpleExecutableActions = resolveSimpleEnqueuedActions(rawActions);
+    if (simpleExecutableActions) {
+      return [snapshot, simpleExecutableActions];
+    }
+    return dist_xstateActors.resolveActionsWithContext(snapshot, event, actorScope, rawActions);
+  };
+  const runStateActions = (snapshot, event, actorScope, actionsConfig, stateInput, internalQueue) => {
+    if (!actionsConfig) {
+      return [snapshot, emptyExecutableActions];
+    }
+    const actions = [];
+    const enq = dist_xstateActors.createTransitionEnqueue(actorScope, actions, internalQueue, true);
+    let context;
+    const actionCount = Array.isArray(actionsConfig) ? actionsConfig.length : 1;
+    for (let i = 0; i < actionCount; i++) {
+      const action = Array.isArray(actionsConfig) ? actionsConfig[i] : actionsConfig;
+      const result = action({
+        context: context ?? snapshot.context,
+        event: event,
+        input: stateInput,
+        value: snapshot.value,
+        self: actorScope.self,
+        system: actorScope.system,
+        parent: actorScope.self._parent,
+        children: snapshot.children
+      }, enq);
+      if (result?.context !== undefined) {
+        const currentContext = context ?? snapshot.context;
+        const nextContext = mergeContextPatch(currentContext, result.context);
+        if (nextContext !== currentContext) {
+          context = nextContext;
+        }
+      }
+    }
+    const nextSnapshot = context !== undefined ? cloneSnapshot(snapshot, snapshot.value, context, snapshot._stateInput) : snapshot;
+    return runActions(nextSnapshot, event, actorScope, actions);
+  };
+  const selectTransition = (snapshot, event, actorScope, internalQueue) => {
+    const state = config.states[snapshot.value];
+    const transitionsConfig = state?.on?.[event.type];
+    if (!transitionsConfig) {
+      return undefined;
+    }
+    const transitionCount = Array.isArray(transitionsConfig) ? transitionsConfig.length : 1;
+    for (let i = 0; i < transitionCount; i++) {
+      const transition = Array.isArray(transitionsConfig) ? transitionsConfig[i] : transitionsConfig;
+      const args = {
+        context: snapshot.context,
+        event,
+        input: snapshot.input,
+        value: snapshot.value,
+        self: actorScope.self,
+        system: actorScope.system,
+        parent: actorScope.self._parent,
+        children: snapshot.children
+      };
+      if (typeof transition === 'function') {
+        const actions = [];
+        const enq = dist_xstateActors.createTransitionEnqueue(actorScope, actions, internalQueue, true);
+        const result = transition(args, enq);
+        if (!result) {
+          if (actions.length) {
+            return {
+              actions
+            };
+          }
+          continue;
+        }
+        return {
+          target: result.target,
+          context: result.context,
+          input: result.input,
+          actions
+        };
+      }
+      if ('guard' in transition && transition.guard && !transition.guard(args)) {
+        continue;
+      }
+      return {
+        target: transition.target,
+        context: resolveTransitionContext(transition.context, args),
+        input: transition.input,
+        actions: 'actions' in transition && transition.actions ? toArray(transition.actions) : emptyRawActions
+      };
+    }
+    return undefined;
+  };
+  const transition = (snapshot, event, actorScope) => {
+    if (snapshot.status !== 'active') {
+      return [snapshot, []];
+    }
+    if (event.type === dist_xstateActors.XSTATE_STOP) {
+      return [stopSnapshot(snapshot), emptyExecutableActions];
+    }
+    const stateConfig = config.states[snapshot.value];
+    const directTransition = stateConfig?.on?.[event.type];
+    if (!directTransition) {
+      return [snapshot, emptyExecutableActions];
+    }
+    if (!Array.isArray(directTransition) && typeof directTransition !== 'function' && !('guard' in directTransition) && !('actions' in directTransition && directTransition.actions) && typeof directTransition.input !== 'function') {
+      const target = directTransition.target ?? snapshot.value;
+      const stateChanged = target !== snapshot.value;
+      if (stateChanged && (stateConfig.exit || config.states[target]?.entry)) ; else {
+        const hasContext = directTransition.context !== undefined;
+        const hasInput = directTransition.input !== undefined;
+        const resolvedContext = resolveTransitionContext(directTransition.context, {
+          context: snapshot.context,
+          event,
+          input: snapshot.input,
+          value: snapshot.value,
+          self: actorScope.self,
+          system: actorScope.system,
+          parent: actorScope.self._parent,
+          children: snapshot.children
+        });
+        const context = hasContext && resolvedContext ? mergeContextPatch(snapshot.context, resolvedContext) : snapshot.context;
+        if (!stateChanged && context === snapshot.context && !hasInput && snapshot._stateInput === undefined) {
+          return [snapshot, emptyExecutableActions];
+        }
+        return [cloneSnapshot(snapshot, target, context, hasInput ? resolveInput(directTransition.input, context, event) : undefined), emptyExecutableActions];
+      }
+    }
+    if (typeof directTransition === 'function' && directTransition.length < 2 && !stateConfig?.exit) {
+      const result = directTransition({
+        context: snapshot.context,
+        event,
+        input: snapshot.input,
+        value: snapshot.value,
+        self: actorScope.self,
+        system: actorScope.system,
+        parent: actorScope.self._parent,
+        children: snapshot.children
+      }, undefined);
+      if (result) {
+        const target = result.target ?? snapshot.value;
+        if (!config.states[target]?.entry) {
+          const hasContext = result.context !== undefined;
+          const hasInput = result.input !== undefined;
+          const context = hasContext && result.context ? mergeContextPatch(snapshot.context, result.context) : snapshot.context;
+          if (target === snapshot.value && context === snapshot.context && !hasInput && snapshot._stateInput === undefined) {
+            return [snapshot, emptyExecutableActions];
+          }
+          return [cloneSnapshot(snapshot, target, context, hasInput ? resolveInput(result.input, context, event) : undefined), emptyExecutableActions];
+        }
+      }
+    }
+    let nextSnapshot = snapshot;
+    const executableActions = [];
+    const internalQueue = [event];
+    let iterations = 0;
+    while (internalQueue.length) {
+      if (++iterations > 1000) {
+        throw new Error('FSM microstep count exceeded 1000');
+      }
+      const nextEvent = internalQueue.shift();
+      const selected = selectTransition(nextSnapshot, nextEvent, actorScope, internalQueue);
+      if (!selected) {
+        continue;
+      }
+      const nextValue = selected.target ?? nextSnapshot.value;
+      const stateChanged = nextValue !== nextSnapshot.value;
+      if (stateChanged) {
+        const [exited, exitActions] = runStateActions(nextSnapshot, nextEvent, actorScope, config.states[nextSnapshot.value]?.exit, nextSnapshot._stateInput, internalQueue);
+        nextSnapshot = exited;
+        executableActions.push(...exitActions);
+      }
+      let context = nextSnapshot.context;
+      if (selected.context !== undefined) {
+        context = mergeContextPatch(context, selected.context);
+      }
+      const hasInput = selected.input !== undefined;
+      const stateInput = hasInput ? resolveInput(selected.input, context, nextEvent) : undefined;
+      if (stateChanged || context !== nextSnapshot.context || hasInput || nextSnapshot._stateInput !== undefined) {
+        nextSnapshot = cloneSnapshot(nextSnapshot, nextValue, context, stateInput);
+      }
+      const [afterTransition, transitionActions] = runActions(nextSnapshot, nextEvent, actorScope, selected.actions);
+      nextSnapshot = afterTransition;
+      executableActions.push(...transitionActions);
+      if (stateChanged) {
+        const [entered, entryActions] = runStateActions(nextSnapshot, nextEvent, actorScope, config.states[nextValue]?.entry, stateInput, internalQueue);
+        nextSnapshot = entered;
+        executableActions.push(...entryActions);
+      }
+    }
+    return [nextSnapshot, executableActions];
+  };
+  const logic = {
+    id: config.id,
+    config,
+    transition,
+    initialTransition: (input, actorScope) => {
+      const context = resolveContext(config.context, input);
+      const snapshot = createSnapshot(config.initial, context, input, machine);
+      const internalQueue = [];
+      let [nextSnapshot, actions] = runStateActions(snapshot, {
+        type: dist_xstateActors.XSTATE_INIT
+      }, actorScope, config.states[config.initial]?.entry, undefined, internalQueue);
+      if (!actions.length) {
+        actions = [];
+      }
+      while (internalQueue.length) {
+        const [raisedSnapshot, raisedActions] = transition(nextSnapshot, internalQueue.shift(), actorScope);
+        nextSnapshot = raisedSnapshot;
+        actions.push(...raisedActions);
+      }
+      return [nextSnapshot, actions];
+    },
+    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
+    getPersistedSnapshot: ({
+      machine: _,
+      ...snapshot
+    }) => snapshot,
+    restoreSnapshot: snapshot => ({
+      ...snapshot,
+      machine: machine
+    })
+  };
+  return logic;
+}
+
 function delayToMs(delay) {
   const parsedDelay = dist_xstateActors.parseDelayToMilliseconds(delay);
   if (parsedDelay !== undefined) return parsedDelay;
@@ -2319,6 +2652,7 @@ exports.StateNode = StateMachine.StateNode;
 exports.SimulatedClock = SimulatedClock;
 exports.SpecialTargets = SpecialTargets;
 exports.assertEvent = assertEvent;
+exports.createFSM = createFSM;
 exports.createMachine = createMachine;
 exports.createMachineFromConfig = createMachineFromConfig;
 exports.createStateConfig = createStateConfig;

package/dist/xstate.cjs.mjs

@@ -13,6 +13,7 @@ export {
   createCallbackLogic,
   createEmptyActor,
   createEventObservableLogic,
+  createFSM,
   createListenerLogic,
   createLogic,
   createMachine,