@xstate/react 4.0.0-alpha.0 → 4.0.0-alpha.2

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

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { ActorRefFrom, AnyStateMachine, AreAllImplementationsAssumedToBeProvided, SnapshotFrom, InternalMachineImplementations, InterpreterOptions, Observer, StateFrom } from 'xstate';
+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>;
+    } : {
+        options?: InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta']>;
+    })) => React.ReactElement<any, any>;
+};

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

@@ -1,3 +1,3 @@
-import { MachineImplementationsFrom, ServiceFrom, StateFrom, StateMachine } from '@xstate/fsm';
-export declare function useMachine<TMachine extends StateMachine.AnyMachine>(stateMachine: TMachine, options?: MachineImplementationsFrom<TMachine>): [StateFrom<TMachine>, ServiceFrom<TMachine>['send'], ServiceFrom<TMachine>];
-export declare function useService<TService extends StateMachine.AnyService>(service: TService): [StateFrom<TService>, TService['send'], TService];
+import { MachineImplementationsFrom, ServiceFrom, StateFrom, StateMachine } from '@xstate/fsm';
+export declare function useMachine<TMachine extends StateMachine.AnyMachine>(stateMachine: TMachine, options?: MachineImplementationsFrom<TMachine>): [StateFrom<TMachine>, ServiceFrom<TMachine>['send'], ServiceFrom<TMachine>];
+export declare function useService<TService extends StateMachine.AnyService>(service: TService): [StateFrom<TService>, TService['send'], TService];

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

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

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

@@ -0,0 +1 @@
+export declare function shallowEqual(objA: any, objB: any): boolean;

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

@@ -1,15 +1,15 @@
-import { EventObject, MachineContext, StateConfig } from 'xstate';
-export declare type MaybeLazy<T> = T | (() => T);
-export declare type NoInfer<T> = [T][T extends any ? 0 : any];
-export declare 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>;
-}
+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/useActor.d.ts

@@ -1,3 +1,3 @@
-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 { 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];

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

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

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

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

@@ -1,21 +1,10 @@
-import { AnyStateMachine, AreAllImplementationsAssumedToBeProvided, EventObject, InternalMachineImplementations, InterpreterFrom, InterpreterOptions, MachineContext, StateConfig, StateFrom } from 'xstate';
-import { MaybeLazy, Prop } from './types';
-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>;
-}
-declare type RestParams<TMachine extends AnyStateMachine> = AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends false ? [
-    options: InterpreterOptions & UseMachineOptions<TMachine['__TContext'], TMachine['__TEvent']> & InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta'], true>
-] : [
-    options?: InterpreterOptions & UseMachineOptions<TMachine['__TContext'], TMachine['__TEvent']> & InternalMachineImplementations<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta']>
-];
-declare 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 {};
+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']>
+];
+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/declarations/src/useSelector.d.ts

@@ -1,2 +1,2 @@
-import { ActorRef, SnapshotFrom } from 'xstate';
-export declare function useSelector<TActor extends ActorRef<any, any>, T>(actor: TActor, selector: (emitted: SnapshotFrom<TActor>) => T, compare?: (a: T, b: T) => boolean): T;
+import { ActorRef, SnapshotFrom } from 'xstate';
+export declare function useSelector<TActor extends ActorRef<any, any>, T>(actor: TActor, selector: (emitted: SnapshotFrom<TActor>) => T, compare?: (a: T, b: T) => boolean): T;

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

@@ -1,9 +1,9 @@
-import { ActorRef, Behavior, 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: Behavior<TEvent, TState>): ActorRef<TEvent, TState>;
+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-94bfdbb5.esm.js → useConstant-0013a606.esm.js}

@@ -5,37 +5,36 @@ function _arrayWithHoles(arr) {
 }
 
 function _iterableToArrayLimit(arr, i) {
-  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _e = undefined;
-
-  try {
-    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
+  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 (!_n && _i["return"] != null) _i["return"]();
+      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 {
-      if (_d) throw _e;
+      try {
+        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
     }
+    return _arr;
   }
-
-  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;
 }
 
@@ -58,13 +57,11 @@ function _slicedToArray(arr, i) {
 
 function useConstant(fn) {
   var ref = useRef();
-
   if (!ref.current) {
     ref.current = {
       v: fn()
     };
   }
-
   return ref.current.v;
 }
 

package/dist/{useConstant-eeb49d3f.cjs.prod.js → useConstant-c09b427a.cjs.prod.js}

@@ -4,13 +4,11 @@ var React = require('react');
 
 function useConstant(fn) {
   var ref = React.useRef();
-
   if (!ref.current) {
     ref.current = {
       v: fn()
     };
   }
-
   return ref.current.v;
 }
 

package/dist/{useConstant-644f0e11.cjs.dev.js → useConstant-ff65b597.cjs.dev.js}

@@ -7,37 +7,36 @@ function _arrayWithHoles(arr) {
 }
 
 function _iterableToArrayLimit(arr, i) {
-  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-  var _e = undefined;
-
-  try {
-    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
+  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 (!_n && _i["return"] != null) _i["return"]();
+      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 {
-      if (_d) throw _e;
+      try {
+        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
     }
+    return _arr;
   }
-
-  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;
 }
 
@@ -60,13 +59,11 @@ function _slicedToArray(arr, i) {
 
 function useConstant(fn) {
   var ref = React.useRef();
-
   if (!ref.current) {
     ref.current = {
       v: fn()
     };
   }
-
   return ref.current.v;
 }