@xstate/react 4.0.0-alpha.2 → 4.0.0-beta.4

package/dist/declarations/src/createActorContext.d.ts

@@ -1,15 +1,15 @@
 import * as React from 'react';
-import { ActorRefFrom, AnyStateMachine, AreAllImplementationsAssumedToBeProvided, SnapshotFrom, InternalMachineImplementations, InterpreterOptions, Observer, StateFrom } from 'xstate';
+import { ActorRefFrom, AnyStateMachine, SnapshotFrom, InterpreterOptions, Observer, StateFrom, AreAllImplementationsAssumedToBeProvided, MarkAllImplementationsAsProvided, StateMachine } from 'xstate';
+type ToMachinesWithProvidedImplementations<TMachine extends AnyStateMachine> = TMachine extends StateMachine<infer TContext, infer TEvent, infer TAction, infer TActorMap, infer TResolvedTypesMeta> ? StateMachine<TContext, TEvent, TAction, TActorMap, AreAllImplementationsAssumedToBeProvided<TResolvedTypesMeta> extends false ? MarkAllImplementationsAsProvided<TResolvedTypesMeta> : TResolvedTypesMeta> : never;
 export declare function createActorContext<TMachine extends AnyStateMachine>(machine: TMachine, interpreterOptions?: InterpreterOptions<TMachine>, observerOrListener?: Observer<StateFrom<TMachine>> | ((value: StateFrom<TMachine>) => void)): {
-    useActor: () => [StateFrom<TMachine>, ActorRefFrom<TMachine>['send']];
     useSelector: <T>(selector: (snapshot: SnapshotFrom<TMachine>) => T, compare?: (a: T, b: T) => boolean) => T;
     useActorRef: () => ActorRefFrom<TMachine>;
     Provider: (props: {
         children: React.ReactNode;
-        machine?: TMachine | (() => TMachine);
-    } & (AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends false ? {
-        options: InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta'], true>;
+    } & (AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? {
+        machine?: TMachine;
     } : {
-        options?: InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta']>;
+        machine: ToMachinesWithProvidedImplementations<TMachine>;
     })) => React.ReactElement<any, any>;
 };
+export {};

package/dist/declarations/src/index.d.ts

@@ -1,7 +1,6 @@
-export { useMachine } from './useMachine.ts';
 export { useActor } from './useActor.ts';
-export { useInterpret } from './useInterpret.ts';
+export { useActorRef } from './useActorRef.ts';
 export { useSelector } from './useSelector.ts';
-export { useSpawn } from './useSpawn.ts';
 export { shallowEqual } from './shallowEqual.ts';
 export { createActorContext } from './createActorContext.ts';
+export { useMachine } from './useMachine.ts';

package/dist/declarations/src/useActor.d.ts

@@ -1,3 +1,6 @@
-import { ActorRef, EventObject, SnapshotFrom } from 'xstate';
-export declare function useActor<TActor extends ActorRef<any, any>>(actorRef: TActor): [SnapshotFrom<TActor>, TActor['send']];
-export declare function useActor<TEvent extends EventObject, TSnapshot>(actorRef: ActorRef<TEvent, TSnapshot>): [TSnapshot, (event: TEvent) => void];
+import { ActorRefFrom, AnyActorBehavior, InterpreterOptions, SnapshotFrom } from 'xstate';
+export declare function useActor<TBehavior extends AnyActorBehavior>(behavior: TBehavior, options?: InterpreterOptions<TBehavior>): [
+    SnapshotFrom<TBehavior>,
+    ActorRefFrom<TBehavior>['send'],
+    ActorRefFrom<TBehavior>
+];

package/dist/declarations/src/useActorRef.d.ts

@@ -0,0 +1,14 @@
+import { AnyActorBehavior, AnyInterpreter, AnyStateMachine, AreAllImplementationsAssumedToBeProvided, InternalMachineImplementations, ActorRefFrom, InterpreterOptions, Observer, StateFrom, SnapshotFrom } from 'xstate';
+export declare function useIdleInterpreter(machine: AnyActorBehavior, options: Partial<InterpreterOptions<AnyActorBehavior>>): AnyInterpreter;
+type RestParams<TBehavior extends AnyActorBehavior> = TBehavior extends AnyStateMachine ? AreAllImplementationsAssumedToBeProvided<TBehavior['__TResolvedTypesMeta']> extends false ? [
+    options: InterpreterOptions<TBehavior> & InternalMachineImplementations<TBehavior['__TContext'], TBehavior['__TEvent'], TBehavior['__TResolvedTypesMeta'], true>,
+    observerOrListener?: Observer<StateFrom<TBehavior>> | ((value: StateFrom<TBehavior>) => void)
+] : [
+    options?: InterpreterOptions<TBehavior> & InternalMachineImplementations<TBehavior['__TContext'], TBehavior['__TEvent'], TBehavior['__TResolvedTypesMeta']>,
+    observerOrListener?: Observer<StateFrom<TBehavior>> | ((value: StateFrom<TBehavior>) => void)
+] : [
+    options?: InterpreterOptions<TBehavior>,
+    observerOrListener?: Observer<SnapshotFrom<TBehavior>> | ((value: SnapshotFrom<TBehavior>) => void)
+];
+export declare function useActorRef<TBehavior extends AnyActorBehavior>(machine: TBehavior, ...[options, observerOrListener]: RestParams<TBehavior>): ActorRefFrom<TBehavior>;
+export {};

package/dist/declarations/src/useMachine.d.ts

@@ -1,10 +1,10 @@
-import { AnyStateMachine, AreAllImplementationsAssumedToBeProvided, InternalMachineImplementations, InterpreterFrom, InterpreterOptions, StateFrom } from 'xstate';
-import { MaybeLazy, Prop } from './types.ts';
-type RestParams<TMachine extends AnyStateMachine> = AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends false ? [
-    options: InterpreterOptions<TMachine> & InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta'], true>
-] : [
-    options?: InterpreterOptions<TMachine> & InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta']>
+import { ActorRefFrom, AnyStateMachine, AreAllImplementationsAssumedToBeProvided, InterpreterOptions, MissingImplementationsError, StateFrom } from 'xstate';
+/**
+ *
+ * @deprecated Use `useActor(...)` instead.
+ */
+export declare function useMachine<TMachine extends AnyStateMachine>(machine: AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends true ? TMachine : MissingImplementationsError<TMachine['__TResolvedTypesMeta']>, options?: InterpreterOptions<TMachine>): [
+    StateFrom<TMachine>,
+    ActorRefFrom<TMachine>['send'],
+    ActorRefFrom<TMachine>
 ];
-type UseMachineReturn<TMachine extends AnyStateMachine, TInterpreter = InterpreterFrom<TMachine>> = [StateFrom<TMachine>, Prop<TInterpreter, 'send'>, TInterpreter];
-export declare function useMachine<TMachine extends AnyStateMachine>(getMachine: MaybeLazy<TMachine>, ...[options]: RestParams<TMachine>): UseMachineReturn<TMachine>;
-export {};

package/dist/{useConstant-ff65b597.cjs.dev.js → useConstant-23e96eea.cjs.dev.js}

@@ -2,6 +2,26 @@
 
 var React = require('react');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
@@ -58,7 +78,7 @@ function _slicedToArray(arr, i) {
 }
 
 function useConstant(fn) {
-  var ref = React.useRef();
+  var ref = React__namespace.useRef();
   if (!ref.current) {
     ref.current = {
       v: fn()

package/dist/useConstant-720f1662.cjs.prod.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var React = require('react');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function useConstant(fn) {
+  var ref = React__namespace.useRef();
+  if (!ref.current) {
+    ref.current = {
+      v: fn()
+    };
+  }
+  return ref.current.v;
+}
+
+exports.useConstant = useConstant;

package/dist/{useConstant-0013a606.esm.js → useConstant-9bbaf12a.esm.js}

@@ -1,4 +1,4 @@
-import { useRef } from 'react';
+import * as React from 'react';
 
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
@@ -56,7 +56,7 @@ function _slicedToArray(arr, i) {
 }
 
 function useConstant(fn) {
-  var ref = useRef();
+  var ref = React.useRef();
   if (!ref.current) {
     ref.current = {
       v: fn()

package/dist/xstate-react.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index.js";
+//# sourceMappingURL=xstate-react.cjs.d.mts.map

package/dist/xstate-react.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xstate-react.cjs.d.mts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}

package/dist/xstate-react.cjs.d.ts

@@ -1 +1,2 @@
 export * from "./declarations/src/index";
+//# sourceMappingURL=xstate-react.cjs.d.ts.map

package/dist/xstate-react.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xstate-react.cjs.d.ts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}

package/dist/xstate-react.cjs.dev.js

@@ -2,94 +2,63 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var useConstant = require('./useConstant-ff65b597.cjs.dev.js');
 var React = require('react');
-var useIsomorphicLayoutEffect = require('use-isomorphic-layout-effect');
 var withSelector = require('use-sync-external-store/shim/with-selector');
 var xstate = require('xstate');
-var shim = require('use-sync-external-store/shim');
+var useConstant = require('./useConstant-23e96eea.cjs.dev.js');
+var useIsomorphicLayoutEffect = require('use-isomorphic-layout-effect');
+var actors = require('xstate/actors');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
-var useIsomorphicLayoutEffect__default = /*#__PURE__*/_interopDefault(useIsomorphicLayoutEffect);
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
   }
-  return target;
+  n["default"] = e;
+  return Object.freeze(n);
 }
 
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
-  if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
-  }
-  return target;
-}
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var useIsomorphicLayoutEffect__default = /*#__PURE__*/_interopDefault(useIsomorphicLayoutEffect);
 
-var _excluded = ["actors", "guards", "actions", "delays"];
-function useIdleInterpreter(getMachine, options) {
-  var machine = useConstant.useConstant(function () {
-    return typeof getMachine === 'function' ? getMachine() : getMachine;
-  });
-  if (process.env.NODE_ENV !== 'production' && typeof getMachine !== 'function') {
+function useIdleInterpreter(machine, options) {
+  if (process.env.NODE_ENV !== 'production') {
     var _useState = React.useState(machine),
       _useState2 = useConstant._slicedToArray(_useState, 1),
       initialMachine = _useState2[0];
-    if (getMachine !== initialMachine) {
-      console.warn('Machine given to `useMachine` has changed between renders. This is not supported and might lead to unexpected results.\n' + 'Please make sure that you pass the same Machine as argument each time.');
+    if (machine.config !== initialMachine.config) {
+      console.warn("Actor logic has changed between renders. This is not supported and may lead to invalid snapshots.");
     }
   }
-  var actors = options.actors,
-    guards = options.guards,
-    actions = options.actions,
-    delays = options.delays,
-    interpreterOptions = _objectWithoutProperties(options, _excluded);
-  var service = useConstant.useConstant(function () {
-    var machineConfig = {
-      guards: guards,
-      actions: actions,
-      actors: actors,
-      delays: delays
-    };
-    var machineWithConfig = machine.provide(machineConfig);
-    return xstate.interpret(machineWithConfig, interpreterOptions);
+  var actorRef = useConstant.useConstant(function () {
+    return xstate.interpret(machine, options);
   });
 
-  // Make sure options are kept updated when they change.
-  // This mutation assignment is safe because the service instance is only used
-  // in one place -- this hook's caller.
-  useIsomorphicLayoutEffect__default['default'](function () {
-    Object.assign(service.behavior.options.actions, actions);
-    Object.assign(service.behavior.options.guards, guards);
-    Object.assign(service.behavior.options.actors, actors);
-    Object.assign(service.behavior.options.delays, delays);
-  }, [actions, guards, actors, delays]);
-  return service;
+  // TODO: consider using `useAsapEffect` that would do this in `useInsertionEffect` is that's available
+  useIsomorphicLayoutEffect__default["default"](function () {
+    actorRef.behavior.options = machine.options;
+  });
+  return actorRef;
 }
-function useInterpret(getMachine) {
+function useActorRef(machine) {
   for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
     _ref[_key - 1] = arguments[_key];
   }
   var _ref$ = _ref[0],
     options = _ref$ === void 0 ? {} : _ref$,
     observerOrListener = _ref[1];
-  var service = useIdleInterpreter(getMachine, options);
+  var service = useIdleInterpreter(machine, options);
   React.useEffect(function () {
     if (!observerOrListener) {
       return;
@@ -116,49 +85,32 @@ function identity(a) {
 var isEqual = function isEqual(prevState, nextState) {
   return prevState === nextState || nextState.changed === false;
 };
-function useMachine(getMachine) {
-  for (var _len = arguments.length, _ref = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    _ref[_key - 1] = arguments[_key];
+function useActor(behavior) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (process.env.NODE_ENV !== 'production') {
+    if (actors.isActorRef(behavior)) {
+      throw new Error("useActor() expects actor logic (e.g. a machine), but received an ActorRef. Use the useSelector(actorRef, ...) hook instead to read the ActorRef's snapshot.");
+    }
   }
-  var _ref$ = _ref[0],
-    options = _ref$ === void 0 ? {} : _ref$;
-  // using `useIdleInterpreter` allows us to subscribe to the service *before* we start it
-  // so we don't miss any notifications
-  var service = useIdleInterpreter(getMachine, options);
+  var actorRef = useIdleInterpreter(behavior, options);
   var getSnapshot = React.useCallback(function () {
-    return service.getSnapshot();
-  }, [service]);
-  var subscribe = React.useCallback(function (handleStoreChange) {
-    var _service$subscribe = service.subscribe(handleStoreChange),
-      unsubscribe = _service$subscribe.unsubscribe;
-    return unsubscribe;
-  }, [service]);
-  var storeSnapshot = withSelector.useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
-  React.useEffect(function () {
-    service.start();
-    return function () {
-      service.stop();
-      service.status = xstate.InterpreterStatus.NotStarted;
-      service._initState();
-    };
-  }, []);
-  return [storeSnapshot, service.send, service];
-}
-
-function useActor(actorRef) {
+    return actorRef.getSnapshot();
+  }, [actorRef]);
   var subscribe = React.useCallback(function (handleStoreChange) {
     var _actorRef$subscribe = actorRef.subscribe(handleStoreChange),
       unsubscribe = _actorRef$subscribe.unsubscribe;
     return unsubscribe;
   }, [actorRef]);
-  var boundGetSnapshot = React.useCallback(function () {
-    return actorRef.getSnapshot();
-  }, [actorRef]);
-  var storeSnapshot = shim.useSyncExternalStore(subscribe, boundGetSnapshot, boundGetSnapshot);
-  var boundSend = React.useCallback(function (event) {
-    return actorRef.send(event);
+  var actorSnapshot = withSelector.useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
+  React.useEffect(function () {
+    actorRef.start();
+    return function () {
+      actorRef.stop();
+      actorRef.status = xstate.InterpreterStatus.NotStarted;
+      actorRef._initState();
+    };
   }, [actorRef]);
-  return [storeSnapshot, boundSend];
+  return [actorSnapshot, actorRef.send, actorRef];
 }
 
 function defaultCompare(a, b) {
@@ -178,29 +130,6 @@ function useSelector(actor, selector) {
   return selectedSnapshot;
 }
 
-/**
- * React hook that spawns an `ActorRef` with the specified `behavior`.
- * The returned `ActorRef` can be used with the `useActor(actorRef)` hook.
- *
- * @param behavior The actor behavior to spawn
- * @returns An ActorRef with the specified `behavior`
- */
-function useSpawn(behavior) {
-  var actorRef = useConstant.useConstant(function () {
-    // TODO: figure out what to do about the name argument
-    return xstate.interpret(behavior);
-  });
-  React.useEffect(function () {
-    var _actorRef$start;
-    (_actorRef$start = actorRef.start) === null || _actorRef$start === void 0 ? void 0 : _actorRef$start.call(actorRef);
-    return function () {
-      var _stop, _ref;
-      (_stop = (_ref = actorRef).stop) === null || _stop === void 0 ? void 0 : _stop.call(_ref);
-    };
-  }, []);
-  return actorRef;
-}
-
 function _typeof(obj) {
   "@babel/helpers - typeof";
 
@@ -235,85 +164,27 @@ function shallowEqual(objA, objB) {
   return true;
 }
 
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return (hint === "string" ? String : Number)(input);
-}
-
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-  return typeof key === "symbol" ? key : String(key);
-}
-
-function _defineProperty(obj, key, value) {
-  key = _toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
-}
-
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    })), keys.push.apply(keys, symbols);
-  }
-  return keys;
-}
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = null != arguments[i] ? arguments[i] : {};
-    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
-      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-    });
-  }
-  return target;
-}
-
 function createActorContext(machine, interpreterOptions, observerOrListener) {
-  var ReactContext = /*#__PURE__*/React.createContext(null);
+  var ReactContext = /*#__PURE__*/React__namespace.createContext(null);
   var OriginalProvider = ReactContext.Provider;
   function Provider(_ref) {
     var children = _ref.children,
       _ref$machine = _ref.machine,
-      providedMachine = _ref$machine === void 0 ? machine : _ref$machine,
-      options = _ref.options;
-    var actor = useInterpret(providedMachine, _objectSpread2(_objectSpread2({}, interpreterOptions), options), observerOrListener);
-    return /*#__PURE__*/React.createElement(OriginalProvider, {
+      providedMachine = _ref$machine === void 0 ? machine : _ref$machine;
+    var actor = useActorRef(providedMachine, interpreterOptions, observerOrListener);
+    return /*#__PURE__*/React__namespace.createElement(OriginalProvider, {
       value: actor,
       children: children
     });
   }
   Provider.displayName = "ActorProvider(".concat(machine.id, ")");
   function useContext() {
-    var actor = React.useContext(ReactContext);
+    var actor = React__namespace.useContext(ReactContext);
     if (!actor) {
       throw new Error("You used a hook from \"".concat(Provider.displayName, "\" but it's not inside a <").concat(Provider.displayName, "> component."));
     }
     return actor;
   }
-  function useActor$1() {
-    var actor = useContext();
-    return useActor(actor);
-  }
   function useSelector$1(selector, compare) {
     var actor = useContext();
     return useSelector(actor, selector, compare);
@@ -321,15 +192,22 @@ function createActorContext(machine, interpreterOptions, observerOrListener) {
   return {
     Provider: Provider,
     useActorRef: useContext,
-    useActor: useActor$1,
     useSelector: useSelector$1
   };
 }
 
+/**
+ *
+ * @deprecated Use `useActor(...)` instead.
+ */
+function useMachine(machine) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return useActor(machine, options);
+}
+
 exports.createActorContext = createActorContext;
 exports.shallowEqual = shallowEqual;
 exports.useActor = useActor;
-exports.useInterpret = useInterpret;
+exports.useActorRef = useActorRef;
 exports.useMachine = useMachine;
 exports.useSelector = useSelector;
-exports.useSpawn = useSpawn;

package/dist/xstate-react.cjs.mjs

@@ -0,0 +1,8 @@
+export {
+  createActorContext,
+  shallowEqual,
+  useActor,
+  useActorRef,
+  useMachine,
+  useSelector
+} from "./xstate-react.cjs.js";