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

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-0013a606.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.3",
+  "version": "4.0.0-beta.5",
   "description": "XState tools for React",
   "keywords": [
     "state",
@@ -19,15 +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": [
@@ -45,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.7"
+    "xstate": "^5.0.0-beta.13"
   },
   "peerDependenciesMeta": {
     "@xstate/fsm": {
@@ -56,7 +82,7 @@
     }
   },
   "dependencies": {
-    "use-isomorphic-layout-effect": "^1.0.0",
+    "use-isomorphic-layout-effect": "^1.1.2",
     "use-sync-external-store": "^1.0.0"
   },
   "devDependencies": {
@@ -70,7 +96,7 @@
     "jsdom-global": "^3.0.2",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
-    "xstate": "5.0.0-beta.7"
+    "xstate": "5.0.0-beta.13"
   },
   "preconstruct": {
     "entrypoints": [

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

@@ -1,15 +0,0 @@
-import { EventObject, MachineContext, StateConfig } from 'xstate';
-export type MaybeLazy<T> = T | (() => T);
-export type NoInfer<T> = [T][T extends any ? 0 : any];
-export type Prop<T, K> = K extends keyof T ? T[K] : never;
-export interface UseMachineOptions<TContext extends MachineContext, TEvent extends EventObject> {
-    /**
-     * If provided, will be merged with machine's `context`.
-     */
-    context?: Partial<TContext>;
-    /**
-     * The state to rehydrate the machine to. The machine will
-     * start at this state instead of its `initialState`.
-     */
-    state?: StateConfig<TContext, TEvent>;
-}

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

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

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

@@ -1,12 +0,0 @@
-import { AnyInterpreter, AnyStateMachine, AreAllImplementationsAssumedToBeProvided, InternalMachineImplementations, InterpreterFrom, InterpreterOptions, MachineImplementations, Observer, StateFrom } from 'xstate';
-import { MaybeLazy } from './types.ts';
-export declare function useIdleInterpreter(getMachine: MaybeLazy<AnyStateMachine>, options: Partial<InterpreterOptions<AnyStateMachine>> & Partial<MachineImplementations<any, never>>): AnyInterpreter;
-type RestParams<TMachine extends AnyStateMachine> = AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends false ? [
-    options: InterpreterOptions<TMachine> & InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta'], true>,
-    observerOrListener?: Observer<StateFrom<TMachine>> | ((value: StateFrom<TMachine>) => void)
-] : [
-    options?: InterpreterOptions<TMachine> & InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta']>,
-    observerOrListener?: Observer<StateFrom<TMachine>> | ((value: StateFrom<TMachine>) => void)
-];
-export declare function useInterpret<TMachine extends AnyStateMachine>(getMachine: MaybeLazy<TMachine>, ...[options, observerOrListener]: RestParams<TMachine>): InterpreterFrom<TMachine>;
-export {};

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

@@ -1,9 +0,0 @@
-import { ActorRef, ActorBehavior, EventObject } from 'xstate';
-/**
- * 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`
- */
-export declare function useSpawn<TState, TEvent extends EventObject>(behavior: ActorBehavior<TEvent, TState>): ActorRef<TEvent, TState>;

package/dist/useConstant-0013a606.esm.js

@@ -1,68 +0,0 @@
-import { useRef } from 'react';
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArrayLimit(arr, i) {
-  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
-  if (null != _i) {
-    var _s,
-      _e,
-      _x,
-      _r,
-      _arr = [],
-      _n = !0,
-      _d = !1;
-    try {
-      if (_x = (_i = _i.call(arr)).next, 0 === i) {
-        if (Object(_i) !== _i) return;
-        _n = !1;
-      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
-    } catch (err) {
-      _d = !0, _e = err;
-    } finally {
-      try {
-        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
-      } finally {
-        if (_d) throw _e;
-      }
-    }
-    return _arr;
-  }
-}
-
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-
-function useConstant(fn) {
-  var ref = useRef();
-  if (!ref.current) {
-    ref.current = {
-      v: fn()
-    };
-  }
-  return ref.current.v;
-}
-
-export { _slicedToArray as _, useConstant as u };

package/dist/useConstant-ff65b597.cjs.dev.js

@@ -1,71 +0,0 @@
-'use strict';
-
-var React = require('react');
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArrayLimit(arr, i) {
-  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
-  if (null != _i) {
-    var _s,
-      _e,
-      _x,
-      _r,
-      _arr = [],
-      _n = !0,
-      _d = !1;
-    try {
-      if (_x = (_i = _i.call(arr)).next, 0 === i) {
-        if (Object(_i) !== _i) return;
-        _n = !1;
-      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
-    } catch (err) {
-      _d = !0, _e = err;
-    } finally {
-      try {
-        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
-      } finally {
-        if (_d) throw _e;
-      }
-    }
-    return _arr;
-  }
-}
-
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-  return arr2;
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-
-function useConstant(fn) {
-  var ref = React.useRef();
-  if (!ref.current) {
-    ref.current = {
-      v: fn()
-    };
-  }
-  return ref.current.v;
-}
-
-exports._slicedToArray = _slicedToArray;
-exports.useConstant = useConstant;