xstate 5.0.0-beta.18 → 5.0.0-beta.20

package/dist/{actions-40bd643f.development.cjs.js → actions-d1c41ed3.development.cjs.js}

@@ -4,9 +4,6 @@ var dev_dist_xstateDev = require('../dev/dist/xstate-dev.development.cjs.js');
 
 // https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
 
-// TODO: replace in v5 with:
-// export type IndexByType<T extends { type: string }> = { [E in T as E['type']]: E; };
-
 /**
  * The full definition of an event, with a string `type`.
  */
@@ -15,8 +12,6 @@ var dev_dist_xstateDev = require('../dev/dist/xstate-dev.development.cjs.js');
 // we should also accept a raw machine as actor logic here
 // or just make machine actor logic
 
-// TODO: narrow this to logic from machine
-
 /**
  * The string or object representing the state value relative to the parent state node.
  *
@@ -323,7 +318,7 @@ const symbolObservable = (() => typeof Symbol === 'function' && Symbol.observabl
  * @returns Actor logic
  */
 function fromTransition(transition, initialState) {
-  const logic = {
+  return {
     config: transition,
     transition: (state, event, actorContext) => {
       return transition(state, event, actorContext);
@@ -337,95 +332,260 @@ function fromTransition(transition, initialState) {
     getPersistedState: state => state,
     restoreState: state => state
   };
-  return logic;
 }
 
-const resolveEventType = '$$xstate.resolve';
-const rejectEventType = '$$xstate.reject';
-function fromPromise(
-// TODO: add types
-promiseCreator) {
-  // TODO: add event types, consider making the `PromiseEvent` a private type or smth alike
+function matchesState(parentStateId, childStateId) {
+  const parentStateValue = toStateValue(parentStateId);
+  const childStateValue = toStateValue(childStateId);
+  if (typeof childStateValue === 'string') {
+    if (typeof parentStateValue === 'string') {
+      return childStateValue === parentStateValue;
+    }
+
+    // Parent more specific than child
+    return false;
+  }
+  if (typeof parentStateValue === 'string') {
+    return parentStateValue in childStateValue;
+  }
+  return Object.keys(parentStateValue).every(key => {
+    if (!(key in childStateValue)) {
+      return false;
+    }
+    return matchesState(parentStateValue[key], childStateValue[key]);
+  });
+}
+function toStatePath(stateId) {
+  try {
+    if (isArray(stateId)) {
+      return stateId;
+    }
+    return stateId.toString().split(STATE_DELIMITER);
+  } catch (e) {
+    throw new Error(`'${stateId}' is not a valid state path.`);
+  }
+}
+function isStateLike(state) {
+  return typeof state === 'object' && 'value' in state && 'context' in state && 'event' in state;
+}
+function toStateValue(stateValue) {
+  if (isStateLike(stateValue)) {
+    return stateValue.value;
+  }
+  if (isArray(stateValue)) {
+    return pathToStateValue(stateValue);
+  }
+  if (typeof stateValue !== 'string') {
+    return stateValue;
+  }
+  const statePath = toStatePath(stateValue);
+  return pathToStateValue(statePath);
+}
+function pathToStateValue(statePath) {
+  if (statePath.length === 1) {
+    return statePath[0];
+  }
+  const value = {};
+  let marker = value;
+  for (let i = 0; i < statePath.length - 1; i++) {
+    if (i === statePath.length - 2) {
+      marker[statePath[i]] = statePath[i + 1];
+    } else {
+      const previous = marker;
+      marker = {};
+      previous[statePath[i]] = marker;
+    }
+  }
+  return value;
+}
+function mapValues(collection, iteratee) {
+  const result = {};
+  const collectionKeys = Object.keys(collection);
+  for (let i = 0; i < collectionKeys.length; i++) {
+    const key = collectionKeys[i];
+    result[key] = iteratee(collection[key], key, collection, i);
+  }
+  return result;
+}
+function flatten(array) {
+  return [].concat(...array);
+}
+function toArrayStrict(value) {
+  if (isArray(value)) {
+    return value;
+  }
+  return [value];
+}
+function toArray(value) {
+  if (value === undefined) {
+    return [];
+  }
+  return toArrayStrict(value);
+}
+function mapContext(mapper, context, event) {
+  if (typeof mapper === 'function') {
+    return mapper({
+      context,
+      event
+    });
+  }
+  const result = {};
+  const args = {
+    context,
+    event
+  };
+  for (const key of Object.keys(mapper)) {
+    const subMapper = mapper[key];
+    if (typeof subMapper === 'function') {
+      result[key] = subMapper(args);
+    } else {
+      result[key] = subMapper;
+    }
+  }
+  return result;
+}
+function isPromiseLike(value) {
+  if (value instanceof Promise) {
+    return true;
+  }
+  // Check if shape matches the Promise/A+ specification for a "thenable".
+  if (value !== null && (typeof value === 'function' || typeof value === 'object') && typeof value.then === 'function') {
+    return true;
+  }
+  return false;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isErrorEvent(event) {
+  return typeof event.type === 'string' && (event.type === errorExecution || event.type.startsWith(errorPlatform));
+}
+function toTransitionConfigArray(configLike) {
+  return toArrayStrict(configLike).map(transitionLike => {
+    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string') {
+      return {
+        target: transitionLike
+      };
+    }
+    return transitionLike;
+  });
+}
+function normalizeTarget(target) {
+  if (target === undefined || target === TARGETLESS_KEY) {
+    return undefined;
+  }
+  return toArray(target);
+}
+function toInvokeConfig(invocable, id) {
+  if (typeof invocable === 'object') {
+    if ('src' in invocable) {
+      return invocable;
+    }
+    if ('transition' in invocable) {
+      return {
+        id,
+        src: invocable
+      };
+    }
+  }
+  return {
+    id,
+    src: invocable
+  };
+}
+function toObserver(nextHandler, errorHandler, completionHandler) {
+  const noop = () => {};
+  const isObserver = typeof nextHandler === 'object';
+  const self = isObserver ? nextHandler : null;
+  return {
+    next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self),
+    error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self),
+    complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self)
+  };
+}
+function createInvokeId(stateNodeId, index) {
+  return `${stateNodeId}:invocation[${index}]`;
+}
+function resolveReferencedActor(referenced) {
+  return referenced ? 'transition' in referenced ? {
+    src: referenced,
+    input: undefined
+  } : referenced : undefined;
+}
+
+function fromCallback(invokeCallback) {
   const logic = {
-    config: promiseCreator,
-    transition: (state, event) => {
-      if (state.status !== 'active') {
-        return state;
-      }
-      switch (event.type) {
-        case resolveEventType:
-          return {
-            ...state,
-            status: 'done',
-            data: event.data,
-            input: undefined
-          };
-        case rejectEventType:
-          return {
-            ...state,
-            status: 'error',
-            data: event.data,
-            input: undefined
-          };
-        case stopSignalType:
-          return {
-            ...state,
-            status: 'canceled',
-            input: undefined
-          };
-        default:
-          return state;
-      }
+    config: invokeCallback,
+    start: (_state, {
+      self
+    }) => {
+      self.send({
+        type: startSignalType
+      });
     },
-    start: (state, {
+    transition: (state, event, {
       self,
+      id,
       system
     }) => {
-      // TODO: determine how to allow customizing this so that promises
-      // can be restarted if necessary
-      if (state.status !== 'active') {
-        return;
-      }
-      const resolvedPromise = Promise.resolve(promiseCreator({
-        input: state.input,
-        system
-      }));
-      resolvedPromise.then(response => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
-        }
-        self.send({
-          type: resolveEventType,
-          data: response
+      if (event.type === startSignalType) {
+        const sendBack = eventForParent => {
+          if (state.canceled) {
+            return;
+          }
+          self._parent?.send(eventForParent);
+        };
+        const receive = newListener => {
+          state.receivers.add(newListener);
+        };
+        state.dispose = invokeCallback({
+          input: state.input,
+          system,
+          self: self,
+          sendBack,
+          receive
         });
-      }, errorData => {
-        // TODO: remove this condition once dead letter queue lands
-        if (self._state.status !== 'active') {
-          return;
+        if (isPromiseLike(state.dispose)) {
+          state.dispose.then(resolved => {
+            self._parent?.send(doneInvoke(id, resolved));
+            state.canceled = true;
+          }, errorData => {
+            state.canceled = true;
+            self._parent?.send(error(id, errorData));
+          });
         }
-        self.send({
-          type: rejectEventType,
-          data: errorData
-        });
-      });
+        return state;
+      }
+      if (event.type === stopSignalType) {
+        state.canceled = true;
+        if (typeof state.dispose === 'function') {
+          state.dispose();
+        }
+        return state;
+      }
+      if (isSignal(event)) {
+        // TODO: unrecognized signal
+        return state;
+      }
+      state.receivers.forEach(receiver => receiver(event));
+      return state;
     },
     getInitialState: (_, input) => {
       return {
-        status: 'active',
-        data: undefined,
+        canceled: false,
+        receivers: new Set(),
+        dispose: undefined,
         input
       };
     },
-    getSnapshot: state => state.data,
-    getStatus: state => state,
-    getPersistedState: state => state,
-    restoreState: state => state
+    getSnapshot: () => undefined,
+    getPersistedState: ({
+      input
+    }) => input
   };
   return logic;
 }
 
-// TODO: this likely shouldn't accept TEvent, observable actor doesn't accept external events
 function fromObservable(observableCreator) {
   const nextEventType = '$$xstate.next';
   const errorEventType = '$$xstate.error';
@@ -501,7 +661,8 @@ function fromObservable(observableCreator) {
       }
       state.subscription = observableCreator({
         input: state.input,
-        system
+        system,
+        self
       }).subscribe({
         next: value => {
           self.send({
@@ -607,7 +768,8 @@ function fromEventObservable(lazyObservable) {
       }
       state.subscription = lazyObservable({
         input: state.input,
-        system
+        system,
+        self
       }).subscribe({
         next: value => {
           self._parent?.send(value);
@@ -644,251 +806,88 @@ function fromEventObservable(lazyObservable) {
   return logic;
 }
 
-function matchesState(parentStateId, childStateId) {
-  const parentStateValue = toStateValue(parentStateId);
-  const childStateValue = toStateValue(childStateId);
-  if (typeof childStateValue === 'string') {
-    if (typeof parentStateValue === 'string') {
-      return childStateValue === parentStateValue;
-    }
-
-    // Parent more specific than child
-    return false;
-  }
-  if (typeof parentStateValue === 'string') {
-    return parentStateValue in childStateValue;
-  }
-  return Object.keys(parentStateValue).every(key => {
-    if (!(key in childStateValue)) {
-      return false;
-    }
-    return matchesState(parentStateValue[key], childStateValue[key]);
-  });
-}
-function toStatePath(stateId) {
-  try {
-    if (isArray(stateId)) {
-      return stateId;
-    }
-    return stateId.toString().split(STATE_DELIMITER);
-  } catch (e) {
-    throw new Error(`'${stateId}' is not a valid state path.`);
-  }
-}
-function isStateLike(state) {
-  return typeof state === 'object' && 'value' in state && 'context' in state && 'event' in state;
-}
-function toStateValue(stateValue) {
-  if (isStateLike(stateValue)) {
-    return stateValue.value;
-  }
-  if (isArray(stateValue)) {
-    return pathToStateValue(stateValue);
-  }
-  if (typeof stateValue !== 'string') {
-    return stateValue;
-  }
-  const statePath = toStatePath(stateValue);
-  return pathToStateValue(statePath);
-}
-function pathToStateValue(statePath) {
-  if (statePath.length === 1) {
-    return statePath[0];
-  }
-  const value = {};
-  let marker = value;
-  for (let i = 0; i < statePath.length - 1; i++) {
-    if (i === statePath.length - 2) {
-      marker[statePath[i]] = statePath[i + 1];
-    } else {
-      const previous = marker;
-      marker = {};
-      previous[statePath[i]] = marker;
-    }
-  }
-  return value;
-}
-function mapValues(collection, iteratee) {
-  const result = {};
-  const collectionKeys = Object.keys(collection);
-  for (let i = 0; i < collectionKeys.length; i++) {
-    const key = collectionKeys[i];
-    result[key] = iteratee(collection[key], key, collection, i);
-  }
-  return result;
-}
-function flatten(array) {
-  return [].concat(...array);
-}
-function toArrayStrict(value) {
-  if (isArray(value)) {
-    return value;
-  }
-  return [value];
-}
-function toArray(value) {
-  if (value === undefined) {
-    return [];
-  }
-  return toArrayStrict(value);
-}
-function mapContext(mapper, context, event) {
-  if (typeof mapper === 'function') {
-    return mapper({
-      context,
-      event
-    });
-  }
-  const result = {};
-  const args = {
-    context,
-    event
-  };
-  for (const key of Object.keys(mapper)) {
-    const subMapper = mapper[key];
-    if (typeof subMapper === 'function') {
-      result[key] = subMapper(args);
-    } else {
-      result[key] = subMapper;
-    }
-  }
-  return result;
-}
-function isPromiseLike(value) {
-  if (value instanceof Promise) {
-    return true;
-  }
-  // Check if shape matches the Promise/A+ specification for a "thenable".
-  if (value !== null && (typeof value === 'function' || typeof value === 'object') && typeof value.then === 'function') {
-    return true;
-  }
-  return false;
-}
-function isArray(value) {
-  return Array.isArray(value);
-}
-function isErrorEvent(event) {
-  return typeof event.type === 'string' && (event.type === errorExecution || event.type.startsWith(errorPlatform));
-}
-function toTransitionConfigArray(configLike) {
-  return toArrayStrict(configLike).map(transitionLike => {
-    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string') {
-      return {
-        target: transitionLike
-      };
-    }
-    return transitionLike;
-  });
-}
-function normalizeTarget(target) {
-  if (target === undefined || target === TARGETLESS_KEY) {
-    return undefined;
-  }
-  return toArray(target);
-}
-function toInvokeConfig(invocable, id) {
-  if (typeof invocable === 'object') {
-    if ('src' in invocable) {
-      return invocable;
-    }
-    if ('transition' in invocable) {
-      return {
-        id,
-        src: invocable
-      };
-    }
-  }
-  return {
-    id,
-    src: invocable
-  };
-}
-function toObserver(nextHandler, errorHandler, completionHandler) {
-  const noop = () => {};
-  const isObserver = typeof nextHandler === 'object';
-  const self = isObserver ? nextHandler : null;
-  return {
-    next: ((isObserver ? nextHandler.next : nextHandler) || noop).bind(self),
-    error: ((isObserver ? nextHandler.error : errorHandler) || noop).bind(self),
-    complete: ((isObserver ? nextHandler.complete : completionHandler) || noop).bind(self)
-  };
-}
-function createInvokeId(stateNodeId, index) {
-  return `${stateNodeId}:invocation[${index}]`;
-}
-function resolveReferencedActor(referenced) {
-  return referenced ? 'transition' in referenced ? {
-    src: referenced,
-    input: undefined
-  } : referenced : undefined;
-}
-
-function fromCallback(invokeCallback) {
+const resolveEventType = '$$xstate.resolve';
+const rejectEventType = '$$xstate.reject';
+function fromPromise(
+// TODO: add types
+promiseCreator) {
+  // TODO: add event types
   const logic = {
-    config: invokeCallback,
-    start: (_state, {
-      self
-    }) => {
-      self.send({
-        type: startSignalType
-      });
+    config: promiseCreator,
+    transition: (state, event) => {
+      if (state.status !== 'active') {
+        return state;
+      }
+      switch (event.type) {
+        case resolveEventType:
+          return {
+            ...state,
+            status: 'done',
+            data: event.data,
+            input: undefined
+          };
+        case rejectEventType:
+          return {
+            ...state,
+            status: 'error',
+            data: event.data,
+            input: undefined
+          };
+        case stopSignalType:
+          return {
+            ...state,
+            status: 'canceled',
+            input: undefined
+          };
+        default:
+          return state;
+      }
     },
-    transition: (state, event, {
+    start: (state, {
       self,
-      id,
       system
     }) => {
-      if (event.type === startSignalType) {
-        const sender = eventForParent => {
-          if (state.canceled) {
-            return;
-          }
-          self._parent?.send(eventForParent);
-        };
-        const receiver = newListener => {
-          state.receivers.add(newListener);
-        };
-        state.dispose = invokeCallback(sender, receiver, {
-          input: state.input,
-          system
-        });
-        if (isPromiseLike(state.dispose)) {
-          state.dispose.then(resolved => {
-            self._parent?.send(doneInvoke(id, resolved));
-            state.canceled = true;
-          }, errorData => {
-            state.canceled = true;
-            self._parent?.send(error(id, errorData));
-          });
-        }
-        return state;
+      // TODO: determine how to allow customizing this so that promises
+      // can be restarted if necessary
+      if (state.status !== 'active') {
+        return;
       }
-      if (event.type === stopSignalType) {
-        state.canceled = true;
-        if (typeof state.dispose === 'function') {
-          state.dispose();
+      const resolvedPromise = Promise.resolve(promiseCreator({
+        input: state.input,
+        system,
+        self
+      }));
+      resolvedPromise.then(response => {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
         }
-        return state;
-      }
-      if (isSignal(event)) {
-        // TODO: unrecognized signal
-        return state;
-      }
-      state.receivers.forEach(receiver => receiver(event));
-      return state;
+        self.send({
+          type: resolveEventType,
+          data: response
+        });
+      }, errorData => {
+        // TODO: remove this condition once dead letter queue lands
+        if (self._state.status !== 'active') {
+          return;
+        }
+        self.send({
+          type: rejectEventType,
+          data: errorData
+        });
+      });
     },
     getInitialState: (_, input) => {
       return {
-        canceled: false,
-        receivers: new Set(),
-        dispose: undefined,
+        status: 'active',
+        data: undefined,
         input
       };
     },
-    getSnapshot: () => undefined,
-    getPersistedState: ({
-      input
-    }) => input
+    getSnapshot: state => state.data,
+    getStatus: state => state,
+    getPersistedState: state => state,
+    restoreState: state => state
   };
   return logic;
 }
@@ -927,6 +926,7 @@ function toActorRef(actorRefLike) {
     id: 'anonymous',
     sessionId: '',
     getSnapshot: () => undefined,
+    // TODO: this isn't safe
     [symbolObservable]: function () {
       return this;
     },
@@ -2820,7 +2820,7 @@ function createSpawner(actorContext, {
     }
   };
   return (src, options) => {
-    const actorRef = spawn(src, options);
+    const actorRef = spawn(src, options); // TODO: fix types
     spawnedChildren[actorRef.id] = actorRef;
     actorContext.defer(() => {
       if (actorRef.status === ActorStatus.Stopped) {