xstate 5.0.0-beta.23 → 5.0.0-beta.25

package/dist/{actions-0fcd4d15.development.cjs.js → actions-0971b43d.development.cjs.js}

@@ -1496,148 +1496,108 @@ function invoke({
   return invoke;
 }
 
+function checkStateIn(state, _, {
+  stateValue
+}) {
+  if (typeof stateValue === 'string' && isStateId(stateValue)) {
+    return state.configuration.some(sn => sn.id === stateValue.slice(1));
+  }
+  return state.matches(stateValue);
+}
 function stateIn(stateValue) {
-  return {
-    type: 'xstate.guard:in',
-    params: {
-      stateValue
-    },
-    predicate: ({
-      state
-    }) => {
-      if (typeof stateValue === 'string' && isStateId(stateValue)) {
-        return state.configuration.some(sn => sn.id === stateValue.slice(1));
-      }
-      return state.matches(stateValue);
+  function stateIn(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  };
+  }
+  stateIn.check = checkStateIn;
+  stateIn.stateValue = stateValue;
+  return stateIn;
+}
+function checkNot(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return !evaluateGuard(guards[0], context, event, state);
 }
 function not(guard) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'not'
-    },
-    children: [toGuardDefinition(guard)],
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return !evaluate(guard.children[0], context, event, state);
+  function not(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  };
+  }
+  not.check = checkNot;
+  not.guards = [guard];
+  return not;
+}
+function checkAnd(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return guards.every(guard => evaluateGuard(guard, context, event, state));
 }
 function and(guards) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'and'
-    },
-    children: guards.map(guard => toGuardDefinition(guard)),
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return guard.children.every(childGuard => {
-        return evaluate(childGuard, context, event, state);
-      });
+  function and(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  };
+  }
+  and.check = checkAnd;
+  and.guards = guards;
+  return and;
+}
+function checkOr(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return guards.some(guard => evaluateGuard(guard, context, event, state));
 }
 function or(guards) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'or'
-    },
-    children: guards.map(guard => toGuardDefinition(guard)),
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return guard.children.some(childGuard => {
-        return evaluate(childGuard, context, event, state);
-      });
+  function or(_) {
+    {
+      throw new Error(`This isn't supposed to be called`);
     }
-  };
+  }
+  or.check = checkOr;
+  or.guards = guards;
+  return or;
 }
+
+// TODO: throw on cycles (depth check should be enough)
 function evaluateGuard(guard, context, event, state) {
   const {
     machine
   } = state;
-  const predicate = machine?.implementations?.guards?.[guard.type] ?? guard.predicate;
-  if (!predicate) {
-    throw new Error(`Guard '${guard.type}' is not implemented.'.`);
+  const isInline = typeof guard === 'function';
+  const resolved = isInline ? guard : machine.implementations.guards[typeof guard === 'string' ? guard : guard.type];
+  if (!isInline && !resolved) {
+    throw new Error(`Guard '${typeof guard === 'string' ? guard : guard.type}' is not implemented.'.`);
+  }
+  if (typeof resolved !== 'function') {
+    return evaluateGuard(resolved, context, event, state);
   }
-  return predicate({
+  const guardArgs = {
     context,
     event,
-    state,
-    guard,
-    evaluate: evaluateGuard
-  });
-}
-function toGuardDefinition(guardConfig, getPredicate) {
-  // TODO: check for cycles and consider a refactor to more lazily evaluated guards
-  // TODO: resolve this more recursively: https://github.com/statelyai/xstate/pull/4064#discussion_r1229915724
-  if (typeof guardConfig === 'string') {
-    const predicateOrDef = getPredicate?.(guardConfig);
-    if (typeof predicateOrDef === 'function') {
-      return {
-        type: guardConfig,
-        predicate: predicateOrDef,
-        params: {
-          type: guardConfig
-        }
-      };
-    } else if (predicateOrDef) {
-      return predicateOrDef;
-    } else {
-      return {
-        type: guardConfig,
-        params: {
-          type: guardConfig
-        }
-      };
-    }
-  }
-  if (typeof guardConfig === 'function') {
-    return {
-      type: guardConfig.name,
-      predicate: guardConfig,
-      params: {
-        type: guardConfig.name,
-        name: guardConfig.name
-      }
-    };
-  }
-  const predicateOrDef = getPredicate?.(guardConfig.type);
-  if (typeof predicateOrDef === 'function') {
-    return {
-      type: guardConfig.type,
-      params: guardConfig.params || guardConfig,
-      children: guardConfig.children?.map(childGuard => toGuardDefinition(childGuard, getPredicate)),
-      predicate: getPredicate?.(guardConfig.type) || guardConfig.predicate
-    };
-  } else if (predicateOrDef) {
-    return predicateOrDef;
-  } else {
-    return {
-      type: guardConfig.type,
-      params: guardConfig.params || guardConfig,
-      children: guardConfig.children?.map(childGuard => toGuardDefinition(childGuard, getPredicate)),
-      predicate: guardConfig.predicate
-    };
+    guard: isInline ? undefined : typeof guard === 'string' ? {
+      type: guard
+    } : guard
+  };
+  if (!('check' in resolved)) {
+    // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
+    // inline guards expect `TExpressionGuard` to be set to `undefined`
+    // it's fine to cast this here, our logic makes sure that we call those 2 "variants" correctly
+    return resolved(guardArgs);
   }
+  const builtinGuard = resolved;
+  return builtinGuard.check(state, guardArgs, resolved // this holds all params
+  );
 }
 
 function getOutput(configuration, context, event, self) {
@@ -1833,9 +1793,6 @@ function getDelayedTransitions(stateNode) {
 function formatTransition(stateNode, descriptor, transitionConfig) {
   const normalizedTarget = normalizeTarget(transitionConfig.target);
   const reenter = transitionConfig.reenter ?? false;
-  const {
-    guards
-  } = stateNode.machine.implementations;
   const target = resolveTarget(stateNode, normalizedTarget);
 
   // TODO: should this be part of a lint rule instead?
@@ -1845,7 +1802,7 @@ function formatTransition(stateNode, descriptor, transitionConfig) {
   const transition = {
     ...transitionConfig,
     actions: toArray(transitionConfig.actions),
-    guard: transitionConfig.guard ? toGuardDefinition(transitionConfig.guard, guardType => guards[guardType]) : undefined,
+    guard: transitionConfig.guard,
     target,
     source: stateNode,
     reenter,
@@ -2450,7 +2407,7 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     if (!resolved) {
       continue;
     }
-    const args = {
+    const actionArgs = {
       context: intermediateState.context,
       event,
       self: actorCtx?.self,
@@ -2461,14 +2418,14 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     };
     if (!('resolve' in resolved)) {
       if (actorCtx?.self.status === ActorStatus.Running) {
-        resolved(args);
+        resolved(actionArgs);
       } else {
-        actorCtx?.defer(() => resolved(args));
+        actorCtx?.defer(() => resolved(actionArgs));
       }
       continue;
     }
     const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, args, resolved // this holds all params
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
     );
 
     intermediateState = nextState;
@@ -3034,8 +2991,7 @@ function resolve$1(_, state, actionArgs, {
   branches
 }) {
   const matchedActions = branches.find(condition => {
-    const guard = condition.guard && toGuardDefinition(condition.guard, guardType => state.machine.implementations.guards[guardType]);
-    return !guard || evaluateGuard(guard, state.context, actionArgs.event, state);
+    return !condition.guard || evaluateGuard(condition.guard, state.context, actionArgs.event, state);
   })?.actions;
   return [state, undefined, toArray(matchedActions)];
 }
@@ -3206,7 +3162,6 @@ exports.stopSignal = stopSignal;
 exports.stopSignalType = stopSignalType;
 exports.toActorRef = toActorRef;
 exports.toArray = toArray;
-exports.toGuardDefinition = toGuardDefinition;
 exports.toInvokeConfig = toInvokeConfig;
 exports.toObserver = toObserver;
 exports.toTransitionConfigArray = toTransitionConfigArray;

package/dist/{actions-e83129c5.cjs.js → actions-319cefe7.cjs.js}

@@ -1466,148 +1466,100 @@ function invoke({
   return invoke;
 }
 
+function checkStateIn(state, _, {
+  stateValue
+}) {
+  if (typeof stateValue === 'string' && isStateId(stateValue)) {
+    return state.configuration.some(sn => sn.id === stateValue.slice(1));
+  }
+  return state.matches(stateValue);
+}
 function stateIn(stateValue) {
-  return {
-    type: 'xstate.guard:in',
-    params: {
-      stateValue
-    },
-    predicate: ({
-      state
-    }) => {
-      if (typeof stateValue === 'string' && isStateId(stateValue)) {
-        return state.configuration.some(sn => sn.id === stateValue.slice(1));
-      }
-      return state.matches(stateValue);
-    }
-  };
+  function stateIn(_) {
+    return false;
+  }
+  stateIn.check = checkStateIn;
+  stateIn.stateValue = stateValue;
+  return stateIn;
+}
+function checkNot(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return !evaluateGuard(guards[0], context, event, state);
 }
 function not(guard) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'not'
-    },
-    children: [toGuardDefinition(guard)],
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return !evaluate(guard.children[0], context, event, state);
-    }
-  };
+  function not(_) {
+    return false;
+  }
+  not.check = checkNot;
+  not.guards = [guard];
+  return not;
+}
+function checkAnd(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return guards.every(guard => evaluateGuard(guard, context, event, state));
 }
 function and(guards) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'and'
-    },
-    children: guards.map(guard => toGuardDefinition(guard)),
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return guard.children.every(childGuard => {
-        return evaluate(childGuard, context, event, state);
-      });
-    }
-  };
+  function and(_) {
+    return false;
+  }
+  and.check = checkAnd;
+  and.guards = guards;
+  return and;
+}
+function checkOr(state, {
+  context,
+  event
+}, {
+  guards
+}) {
+  return guards.some(guard => evaluateGuard(guard, context, event, state));
 }
 function or(guards) {
-  return {
-    type: 'xstate.boolean',
-    params: {
-      op: 'or'
-    },
-    children: guards.map(guard => toGuardDefinition(guard)),
-    predicate: ({
-      evaluate,
-      guard,
-      context,
-      event,
-      state
-    }) => {
-      return guard.children.some(childGuard => {
-        return evaluate(childGuard, context, event, state);
-      });
-    }
-  };
+  function or(_) {
+    return false;
+  }
+  or.check = checkOr;
+  or.guards = guards;
+  return or;
 }
+
+// TODO: throw on cycles (depth check should be enough)
 function evaluateGuard(guard, context, event, state) {
   const {
     machine
   } = state;
-  const predicate = machine?.implementations?.guards?.[guard.type] ?? guard.predicate;
-  if (!predicate) {
-    throw new Error(`Guard '${guard.type}' is not implemented.'.`);
+  const isInline = typeof guard === 'function';
+  const resolved = isInline ? guard : machine.implementations.guards[typeof guard === 'string' ? guard : guard.type];
+  if (!isInline && !resolved) {
+    throw new Error(`Guard '${typeof guard === 'string' ? guard : guard.type}' is not implemented.'.`);
+  }
+  if (typeof resolved !== 'function') {
+    return evaluateGuard(resolved, context, event, state);
   }
-  return predicate({
+  const guardArgs = {
     context,
     event,
-    state,
-    guard,
-    evaluate: evaluateGuard
-  });
-}
-function toGuardDefinition(guardConfig, getPredicate) {
-  // TODO: check for cycles and consider a refactor to more lazily evaluated guards
-  // TODO: resolve this more recursively: https://github.com/statelyai/xstate/pull/4064#discussion_r1229915724
-  if (typeof guardConfig === 'string') {
-    const predicateOrDef = getPredicate?.(guardConfig);
-    if (typeof predicateOrDef === 'function') {
-      return {
-        type: guardConfig,
-        predicate: predicateOrDef,
-        params: {
-          type: guardConfig
-        }
-      };
-    } else if (predicateOrDef) {
-      return predicateOrDef;
-    } else {
-      return {
-        type: guardConfig,
-        params: {
-          type: guardConfig
-        }
-      };
-    }
-  }
-  if (typeof guardConfig === 'function') {
-    return {
-      type: guardConfig.name,
-      predicate: guardConfig,
-      params: {
-        type: guardConfig.name,
-        name: guardConfig.name
-      }
-    };
-  }
-  const predicateOrDef = getPredicate?.(guardConfig.type);
-  if (typeof predicateOrDef === 'function') {
-    return {
-      type: guardConfig.type,
-      params: guardConfig.params || guardConfig,
-      children: guardConfig.children?.map(childGuard => toGuardDefinition(childGuard, getPredicate)),
-      predicate: getPredicate?.(guardConfig.type) || guardConfig.predicate
-    };
-  } else if (predicateOrDef) {
-    return predicateOrDef;
-  } else {
-    return {
-      type: guardConfig.type,
-      params: guardConfig.params || guardConfig,
-      children: guardConfig.children?.map(childGuard => toGuardDefinition(childGuard, getPredicate)),
-      predicate: guardConfig.predicate
-    };
+    guard: isInline ? undefined : typeof guard === 'string' ? {
+      type: guard
+    } : guard
+  };
+  if (!('check' in resolved)) {
+    // the existing type of `.guards` assumes non-nullable `TExpressionGuard`
+    // inline guards expect `TExpressionGuard` to be set to `undefined`
+    // it's fine to cast this here, our logic makes sure that we call those 2 "variants" correctly
+    return resolved(guardArgs);
   }
+  const builtinGuard = resolved;
+  return builtinGuard.check(state, guardArgs, resolved // this holds all params
+  );
 }
 
 function getOutput(configuration, context, event, self) {
@@ -1797,14 +1749,11 @@ function getDelayedTransitions(stateNode) {
 function formatTransition(stateNode, descriptor, transitionConfig) {
   const normalizedTarget = normalizeTarget(transitionConfig.target);
   const reenter = transitionConfig.reenter ?? false;
-  const {
-    guards
-  } = stateNode.machine.implementations;
   const target = resolveTarget(stateNode, normalizedTarget);
   const transition = {
     ...transitionConfig,
     actions: toArray(transitionConfig.actions),
-    guard: transitionConfig.guard ? toGuardDefinition(transitionConfig.guard, guardType => guards[guardType]) : undefined,
+    guard: transitionConfig.guard,
     target,
     source: stateNode,
     reenter,
@@ -2409,7 +2358,7 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     if (!resolved) {
       continue;
     }
-    const args = {
+    const actionArgs = {
       context: intermediateState.context,
       event,
       self: actorCtx?.self,
@@ -2420,14 +2369,14 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
     };
     if (!('resolve' in resolved)) {
       if (actorCtx?.self.status === ActorStatus.Running) {
-        resolved(args);
+        resolved(actionArgs);
       } else {
-        actorCtx?.defer(() => resolved(args));
+        actorCtx?.defer(() => resolved(actionArgs));
       }
       continue;
     }
     const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, args, resolved // this holds all params
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
     );
 
     intermediateState = nextState;
@@ -2975,8 +2924,7 @@ function resolve$1(_, state, actionArgs, {
   branches
 }) {
   const matchedActions = branches.find(condition => {
-    const guard = condition.guard && toGuardDefinition(condition.guard, guardType => state.machine.implementations.guards[guardType]);
-    return !guard || evaluateGuard(guard, state.context, actionArgs.event, state);
+    return !condition.guard || evaluateGuard(condition.guard, state.context, actionArgs.event, state);
   })?.actions;
   return [state, undefined, toArray(matchedActions)];
 }
@@ -3141,7 +3089,6 @@ exports.stopSignal = stopSignal;
 exports.stopSignalType = stopSignalType;
 exports.toActorRef = toActorRef;
 exports.toArray = toArray;
-exports.toGuardDefinition = toGuardDefinition;
 exports.toInvokeConfig = toInvokeConfig;
 exports.toObserver = toObserver;
 exports.toTransitionConfigArray = toTransitionConfigArray;