@xstate/react 4.0.0-beta.4 → 4.0.0-beta.5

package/dist/xstate-react.esm.js

@@ -1,50 +1,36 @@
 import * as React from 'react';
-import { useEffect, useState, useCallback } from 'react';
+import { useEffect, useCallback } from 'react';
 import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';
 import { toObserver, InterpreterStatus, interpret } from 'xstate';
-import { _ as _slicedToArray, u as useConstant } from './useConstant-9bbaf12a.esm.js';
+import { u as useConstant } from './useConstant-c7ec0fdd.esm.js';
 import useIsomorphicLayoutEffect from 'use-isomorphic-layout-effect';
-import { isActorRef } from 'xstate/actors';
+import 'xstate/actors';
 
 function useIdleInterpreter(machine, options) {
-  if (process.env.NODE_ENV !== 'production') {
-    var _useState = useState(machine),
-      _useState2 = _slicedToArray(_useState, 1),
-      initialMachine = _useState2[0];
-    if (machine.config !== initialMachine.config) {
-      console.warn("Actor logic has changed between renders. This is not supported and may lead to invalid snapshots.");
-    }
-  }
-  var actorRef = useConstant(function () {
+  const actorRef = useConstant(() => {
     return interpret(machine, options);
   });
 
   // TODO: consider using `useAsapEffect` that would do this in `useInsertionEffect` is that's available
-  useIsomorphicLayoutEffect(function () {
+  useIsomorphicLayoutEffect(() => {
     actorRef.behavior.options = machine.options;
   });
   return actorRef;
 }
-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(machine, options);
-  useEffect(function () {
+function useActorRef(machine, ...[options = {}, observerOrListener]) {
+  const service = useIdleInterpreter(machine, options);
+  useEffect(() => {
     if (!observerOrListener) {
       return;
     }
-    var sub = service.subscribe(toObserver(observerOrListener));
-    return function () {
+    let sub = service.subscribe(toObserver(observerOrListener));
+    return () => {
       sub.unsubscribe();
     };
   }, [observerOrListener]);
-  useEffect(function () {
+  useEffect(() => {
     service.start();
-    return function () {
+    return () => {
       service.stop();
       service.status = InterpreterStatus.NotStarted;
       service._initState();
@@ -56,29 +42,24 @@ function useActorRef(machine) {
 function identity(a) {
   return a;
 }
-var isEqual = function isEqual(prevState, nextState) {
+const isEqual = (prevState, nextState) => {
   return prevState === nextState || nextState.changed === false;
 };
-function useActor(behavior) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  if (process.env.NODE_ENV !== 'production') {
-    if (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 actorRef = useIdleInterpreter(behavior, options);
-  var getSnapshot = useCallback(function () {
+function useActor(behavior, options = {}) {
+  const actorRef = useIdleInterpreter(behavior, options);
+  const getSnapshot = useCallback(() => {
     return actorRef.getSnapshot();
   }, [actorRef]);
-  var subscribe = useCallback(function (handleStoreChange) {
-    var _actorRef$subscribe = actorRef.subscribe(handleStoreChange),
-      unsubscribe = _actorRef$subscribe.unsubscribe;
+  const subscribe = useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = actorRef.subscribe(handleStoreChange);
     return unsubscribe;
   }, [actorRef]);
-  var actorSnapshot = useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
-  useEffect(function () {
+  const actorSnapshot = useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
+  useEffect(() => {
     actorRef.start();
-    return function () {
+    return () => {
       actorRef.stop();
       actorRef.status = InterpreterStatus.NotStarted;
       actorRef._initState();
@@ -90,30 +71,18 @@ function useActor(behavior) {
 function defaultCompare(a, b) {
   return a === b;
 }
-function useSelector(actor, selector) {
-  var compare = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultCompare;
-  var subscribe = useCallback(function (handleStoreChange) {
-    var _actor$subscribe = actor.subscribe(handleStoreChange),
-      unsubscribe = _actor$subscribe.unsubscribe;
+function useSelector(actor, selector, compare = defaultCompare) {
+  const subscribe = useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = actor.subscribe(handleStoreChange);
     return unsubscribe;
   }, [actor]);
-  var boundGetSnapshot = useCallback(function () {
-    return actor.getSnapshot();
-  }, [actor]);
-  var selectedSnapshot = useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
+  const boundGetSnapshot = useCallback(() => actor.getSnapshot(), [actor]);
+  const selectedSnapshot = useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
   return selectedSnapshot;
 }
 
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, _typeof(obj);
-}
-
 // From https://github.com/reduxjs/react-redux/blob/720f0ba79236cdc3e1115f4ef9a7760a21784b48/src/utils/shallowEqual.ts
 function is(x, y) {
   if (x === y) {
@@ -124,13 +93,13 @@ function is(x, y) {
 }
 function shallowEqual(objA, objB) {
   if (is(objA, objB)) return true;
-  if (_typeof(objA) !== 'object' || objA === null || _typeof(objB) !== 'object' || objB === null) {
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
     return false;
   }
-  var keysA = Object.keys(objA);
-  var keysB = Object.keys(objB);
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
   if (keysA.length !== keysB.length) return false;
-  for (var i = 0; i < keysA.length; i++) {
+  for (let i = 0; i < keysA.length; i++) {
     if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
       return false;
     }
@@ -139,28 +108,28 @@ function shallowEqual(objA, objB) {
 }
 
 function createActorContext(machine, interpreterOptions, observerOrListener) {
-  var ReactContext = /*#__PURE__*/React.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;
-    var actor = useActorRef(providedMachine, interpreterOptions, observerOrListener);
+  const ReactContext = /*#__PURE__*/React.createContext(null);
+  const OriginalProvider = ReactContext.Provider;
+  function Provider({
+    children,
+    machine: providedMachine = machine
+  }) {
+    const actor = useActorRef(providedMachine, interpreterOptions, observerOrListener);
     return /*#__PURE__*/React.createElement(OriginalProvider, {
       value: actor,
-      children: children
+      children
     });
   }
-  Provider.displayName = "ActorProvider(".concat(machine.id, ")");
+  Provider.displayName = `ActorProvider(${machine.id})`;
   function useContext() {
-    var actor = React.useContext(ReactContext);
+    const actor = React.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."));
+      throw new Error(`You used a hook from "${Provider.displayName}" but it's not inside a <${Provider.displayName}> component.`);
     }
     return actor;
   }
   function useSelector$1(selector, compare) {
-    var actor = useContext();
+    const actor = useContext();
     return useSelector(actor, selector, compare);
   }
   return {
@@ -174,8 +143,7 @@ function createActorContext(machine, interpreterOptions, observerOrListener) {
  *
  * @deprecated Use `useActor(...)` instead.
  */
-function useMachine(machine) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function useMachine(machine, options = {}) {
   return useActor(machine, options);
 }
 

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

@@ -1,7 +1,68 @@
 'use strict';
 
-if (process.env.NODE_ENV === "production") {
-  module.exports = require("./xstate-react-fsm.cjs.prod.js");
-} else {
-  module.exports = require("./xstate-react-fsm.cjs.dev.js");
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fsm = require('@xstate/fsm');
+var React = require('react');
+var useIsomorphicLayoutEffect = require('use-isomorphic-layout-effect');
+var withSelector = require('use-sync-external-store/shim/with-selector');
+var useConstant = require('../../dist/useConstant-2ee82f84.cjs.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var useIsomorphicLayoutEffect__default = /*#__PURE__*/_interopDefault(useIsomorphicLayoutEffect);
+
+function identity(a) {
+  return a;
 }
+function useMachine(stateMachine, options) {
+  const persistedStateRef = React.useRef();
+  const [service, queue] = useConstant.useConstant(() => {
+    const queue = [];
+    const service = fsm.interpret(fsm.createMachine(stateMachine.config, options ? options : stateMachine._options));
+    const {
+      send
+    } = service;
+    service.send = event => {
+      if (service.status === fsm.InterpreterStatus.NotStarted) {
+        queue.push(event);
+        return;
+      }
+      send(event);
+      persistedStateRef.current = service.state;
+    };
+    return [service, queue];
+  });
+
+  // TODO: consider using `useInsertionEffect` if available
+  useIsomorphicLayoutEffect__default["default"](() => {
+    if (options) {
+      service._machine._options = options;
+    }
+  });
+  const useServiceResult = useService(service);
+  React.useEffect(() => {
+    service.start(persistedStateRef.current);
+    queue.forEach(service.send);
+    persistedStateRef.current = service.state;
+    return () => {
+      service.stop();
+    };
+  }, []);
+  return useServiceResult;
+}
+const isEqual = (_prevState, nextState) => nextState.changed === false;
+function useService(service) {
+  const getSnapshot = React.useCallback(() => service.state, [service]);
+  const subscribe = React.useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = service.subscribe(handleStoreChange);
+    return unsubscribe;
+  }, [service]);
+  const storeSnapshot = withSelector.useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
+  return [storeSnapshot, service.send, service];
+}
+
+exports.useMachine = useMachine;
+exports.useService = useService;

package/fsm/dist/xstate-react-fsm.development.cjs.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fsm = require('@xstate/fsm');
+var React = require('react');
+var useIsomorphicLayoutEffect = require('use-isomorphic-layout-effect');
+var withSelector = require('use-sync-external-store/shim/with-selector');
+var useConstant = require('../../dist/useConstant-ae6dceac.development.cjs.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var useIsomorphicLayoutEffect__default = /*#__PURE__*/_interopDefault(useIsomorphicLayoutEffect);
+
+function identity(a) {
+  return a;
+}
+function useMachine(stateMachine, options) {
+  const persistedStateRef = React.useRef();
+  {
+    const [initialMachine] = React.useState(stateMachine);
+    if (stateMachine !== 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.');
+    }
+  }
+  const [service, queue] = useConstant.useConstant(() => {
+    const queue = [];
+    const service = fsm.interpret(fsm.createMachine(stateMachine.config, options ? options : stateMachine._options));
+    const {
+      send
+    } = service;
+    service.send = event => {
+      if (service.status === fsm.InterpreterStatus.NotStarted) {
+        queue.push(event);
+        return;
+      }
+      send(event);
+      persistedStateRef.current = service.state;
+    };
+    return [service, queue];
+  });
+
+  // TODO: consider using `useInsertionEffect` if available
+  useIsomorphicLayoutEffect__default["default"](() => {
+    if (options) {
+      service._machine._options = options;
+    }
+  });
+  const useServiceResult = useService(service);
+  React.useEffect(() => {
+    service.start(persistedStateRef.current);
+    queue.forEach(service.send);
+    persistedStateRef.current = service.state;
+    return () => {
+      service.stop();
+    };
+  }, []);
+  return useServiceResult;
+}
+const isEqual = (_prevState, nextState) => nextState.changed === false;
+function useService(service) {
+  const getSnapshot = React.useCallback(() => service.state, [service]);
+  const subscribe = React.useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = service.subscribe(handleStoreChange);
+    return unsubscribe;
+  }, [service]);
+  const storeSnapshot = withSelector.useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
+  return [storeSnapshot, service.send, service];
+}
+
+exports.useMachine = useMachine;
+exports.useService = useService;

package/fsm/dist/xstate-react-fsm.development.esm.js

@@ -0,0 +1,65 @@
+import { interpret, createMachine, InterpreterStatus } from '@xstate/fsm';
+import { useRef, useState, useEffect, useCallback } from 'react';
+import useIsomorphicLayoutEffect from 'use-isomorphic-layout-effect';
+import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';
+import { u as useConstant } from '../../dist/useConstant-bac83df4.development.esm.js';
+
+function identity(a) {
+  return a;
+}
+function useMachine(stateMachine, options) {
+  const persistedStateRef = useRef();
+  {
+    const [initialMachine] = useState(stateMachine);
+    if (stateMachine !== 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.');
+    }
+  }
+  const [service, queue] = useConstant(() => {
+    const queue = [];
+    const service = interpret(createMachine(stateMachine.config, options ? options : stateMachine._options));
+    const {
+      send
+    } = service;
+    service.send = event => {
+      if (service.status === InterpreterStatus.NotStarted) {
+        queue.push(event);
+        return;
+      }
+      send(event);
+      persistedStateRef.current = service.state;
+    };
+    return [service, queue];
+  });
+
+  // TODO: consider using `useInsertionEffect` if available
+  useIsomorphicLayoutEffect(() => {
+    if (options) {
+      service._machine._options = options;
+    }
+  });
+  const useServiceResult = useService(service);
+  useEffect(() => {
+    service.start(persistedStateRef.current);
+    queue.forEach(service.send);
+    persistedStateRef.current = service.state;
+    return () => {
+      service.stop();
+    };
+  }, []);
+  return useServiceResult;
+}
+const isEqual = (_prevState, nextState) => nextState.changed === false;
+function useService(service) {
+  const getSnapshot = useCallback(() => service.state, [service]);
+  const subscribe = useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = service.subscribe(handleStoreChange);
+    return unsubscribe;
+  }, [service]);
+  const storeSnapshot = useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
+  return [storeSnapshot, service.send, service];
+}
+
+export { useMachine, useService };

package/fsm/dist/xstate-react-fsm.esm.js

@@ -1,70 +1,58 @@
-import { _ as _slicedToArray, u as useConstant } from '../../dist/useConstant-9bbaf12a.esm.js';
 import { interpret, createMachine, InterpreterStatus } from '@xstate/fsm';
-import { useRef, useState, useEffect, useCallback } from 'react';
+import { useRef, useEffect, useCallback } from 'react';
 import useIsomorphicLayoutEffect from 'use-isomorphic-layout-effect';
 import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';
+import { u as useConstant } from '../../dist/useConstant-c7ec0fdd.esm.js';
 
 function identity(a) {
   return a;
 }
 function useMachine(stateMachine, options) {
-  var persistedStateRef = useRef();
-  if (process.env.NODE_ENV !== 'production') {
-    var _useState = useState(stateMachine),
-      _useState2 = _slicedToArray(_useState, 1),
-      initialMachine = _useState2[0];
-    if (stateMachine !== 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.');
-    }
-  }
-  var _useConstant = useConstant(function () {
-      var queue = [];
-      var service = interpret(createMachine(stateMachine.config, options ? options : stateMachine._options));
-      var send = service.send;
-      service.send = function (event) {
-        if (service.status === InterpreterStatus.NotStarted) {
-          queue.push(event);
-          return;
-        }
-        send(event);
-        persistedStateRef.current = service.state;
-      };
-      return [service, queue];
-    }),
-    _useConstant2 = _slicedToArray(_useConstant, 2),
-    service = _useConstant2[0],
-    queue = _useConstant2[1];
+  const persistedStateRef = useRef();
+  const [service, queue] = useConstant(() => {
+    const queue = [];
+    const service = interpret(createMachine(stateMachine.config, options ? options : stateMachine._options));
+    const {
+      send
+    } = service;
+    service.send = event => {
+      if (service.status === InterpreterStatus.NotStarted) {
+        queue.push(event);
+        return;
+      }
+      send(event);
+      persistedStateRef.current = service.state;
+    };
+    return [service, queue];
+  });
 
   // TODO: consider using `useInsertionEffect` if available
-  useIsomorphicLayoutEffect(function () {
+  useIsomorphicLayoutEffect(() => {
     if (options) {
       service._machine._options = options;
     }
   });
-  var useServiceResult = useService(service);
-  useEffect(function () {
+  const useServiceResult = useService(service);
+  useEffect(() => {
     service.start(persistedStateRef.current);
     queue.forEach(service.send);
     persistedStateRef.current = service.state;
-    return function () {
+    return () => {
       service.stop();
     };
   }, []);
   return useServiceResult;
 }
-var isEqual = function isEqual(_prevState, nextState) {
-  return nextState.changed === false;
-};
+const isEqual = (_prevState, nextState) => nextState.changed === false;
 function useService(service) {
-  var getSnapshot = useCallback(function () {
-    return service.state;
-  }, [service]);
-  var subscribe = useCallback(function (handleStoreChange) {
-    var _service$subscribe = service.subscribe(handleStoreChange),
-      unsubscribe = _service$subscribe.unsubscribe;
+  const getSnapshot = useCallback(() => service.state, [service]);
+  const subscribe = useCallback(handleStoreChange => {
+    const {
+      unsubscribe
+    } = service.subscribe(handleStoreChange);
     return unsubscribe;
   }, [service]);
-  var storeSnapshot = useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
+  const storeSnapshot = useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
   return [storeSnapshot, service.send, service];
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xstate/react",
-  "version": "4.0.0-beta.4",
+  "version": "4.0.0-beta.5",
   "description": "XState tools for React",
   "keywords": [
     "state",
@@ -19,17 +19,41 @@
   "module": "dist/xstate-react.esm.js",
   "exports": {
     "./fsm": {
+      "types": {
+        "import": "./fsm/dist/xstate-react-fsm.cjs.mjs",
+        "default": "./fsm/dist/xstate-react-fsm.cjs.js"
+      },
+      "development": {
+        "module": "./fsm/dist/xstate-react-fsm.development.esm.js",
+        "import": "./fsm/dist/xstate-react-fsm.development.cjs.mjs",
+        "default": "./fsm/dist/xstate-react-fsm.development.cjs.js"
+      },
       "module": "./fsm/dist/xstate-react-fsm.esm.js",
       "import": "./fsm/dist/xstate-react-fsm.cjs.mjs",
       "default": "./fsm/dist/xstate-react-fsm.cjs.js"
     },
     ".": {
+      "types": {
+        "import": "./dist/xstate-react.cjs.mjs",
+        "default": "./dist/xstate-react.cjs.js"
+      },
+      "development": {
+        "module": "./dist/xstate-react.development.esm.js",
+        "import": "./dist/xstate-react.development.cjs.mjs",
+        "default": "./dist/xstate-react.development.cjs.js"
+      },
       "module": "./dist/xstate-react.esm.js",
       "import": "./dist/xstate-react.cjs.mjs",
       "default": "./dist/xstate-react.cjs.js"
     },
     "./package.json": "./package.json"
   },
+  "imports": {
+    "#is-development": {
+      "development": "./src/true.ts",
+      "default": "./src/false.ts"
+    }
+  },
   "types": "dist/xstate-react.cjs.d.ts",
   "sideEffects": false,
   "files": [
@@ -47,7 +71,7 @@
   "peerDependencies": {
     "@xstate/fsm": "^3.0.0-beta.2",
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
-    "xstate": "^5.0.0-beta.10"
+    "xstate": "^5.0.0-beta.13"
   },
   "peerDependenciesMeta": {
     "@xstate/fsm": {
@@ -72,7 +96,7 @@
     "jsdom-global": "^3.0.2",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
-    "xstate": "5.0.0-beta.10"
+    "xstate": "5.0.0-beta.13"
   },
   "preconstruct": {
     "entrypoints": [

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

@@ -1 +0,0 @@
-export default function useConstant<T>(fn: () => T): T;