@xstate/react 2.0.0 → 4.0.0-alpha.0

package/es/useConstant.js

@@ -1,8 +0,0 @@
-import * as React from 'react';
-export default function useConstant(fn) {
-    var ref = React.useRef();
-    if (!ref.current) {
-        ref.current = { v: fn() };
-    }
-    return ref.current.v;
-}

package/es/useInterpret.d.ts

@@ -1,13 +0,0 @@
-import { AreAllImplementationsAssumedToBeProvided, InternalMachineOptions, InterpreterFrom, InterpreterOptions, Observer, State, StateMachine } from 'xstate';
-import { MaybeLazy } from './types';
-import { UseMachineOptions } from './useMachine';
-declare type RestParams<TMachine extends StateMachine<any, any, any, any, any, any, any>> = AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends false ? [
-    options: InterpreterOptions & UseMachineOptions<TMachine['__TContext'], TMachine['__TEvent']> & InternalMachineOptions<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta'], true>,
-    observerOrListener?: Observer<State<TMachine['__TContext'], TMachine['__TEvent'], any, TMachine['__TTypestate'], TMachine['__TResolvedTypesMeta']>> | ((value: State<TMachine['__TContext'], TMachine['__TEvent'], any, TMachine['__TTypestate'], TMachine['__TResolvedTypesMeta']>) => void)
-] : [
-    options?: InterpreterOptions & UseMachineOptions<TMachine['__TContext'], TMachine['__TEvent']> & InternalMachineOptions<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta']>,
-    observerOrListener?: Observer<State<TMachine['__TContext'], TMachine['__TEvent'], any, TMachine['__TTypestate'], TMachine['__TResolvedTypesMeta']>> | ((value: State<TMachine['__TContext'], TMachine['__TEvent'], any, TMachine['__TTypestate'], TMachine['__TResolvedTypesMeta']>) => void)
-];
-export declare function useInterpret<TMachine extends StateMachine<any, any, any, any, any, any, any>>(getMachine: MaybeLazy<TMachine>, ...[options, observerOrListener]: RestParams<TMachine>): InterpreterFrom<TMachine>;
-export {};
-//# sourceMappingURL=useInterpret.d.ts.map

package/es/useInterpret.js

@@ -1,116 +0,0 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-import { useState } from 'react';
-import useIsomorphicLayoutEffect from 'use-isomorphic-layout-effect';
-import { interpret, State } from 'xstate';
-import useConstant from './useConstant';
-import { useReactEffectActions } from './useReactEffectActions';
-// copied from core/src/utils.ts
-// it avoids a breaking change between this package and XState which is its peer dep
-function toObserver(nextHandler, errorHandler, completionHandler) {
-    if (typeof nextHandler === 'object') {
-        return nextHandler;
-    }
-    var noop = function () { return void 0; };
-    return {
-        next: nextHandler,
-        error: errorHandler || noop,
-        complete: completionHandler || noop
-    };
-}
-export function useInterpret(getMachine) {
-    var _a = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        _a[_i - 1] = arguments[_i];
-    }
-    var _b = __read(_a, 2), _c = _b[0], options = _c === void 0 ? {} : _c, observerOrListener = _b[1];
-    var machine = useConstant(function () {
-        return typeof getMachine === 'function' ? getMachine() : getMachine;
-    });
-    if (process.env.NODE_ENV !== 'production' &&
-        typeof getMachine !== 'function') {
-        var _d = __read(useState(machine), 1), initialMachine = _d[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.');
-        }
-    }
-    var context = options.context, guards = options.guards, actions = options.actions, services = options.services, delays = options.delays, rehydratedState = options.state, interpreterOptions = __rest(options, ["context", "guards", "actions", "services", "delays", "state"]);
-    // it's not defined in `TypegenMachineOptions` so we can't just unpack this property here freely
-    var activities = options.activities;
-    var service = useConstant(function () {
-        var machineConfig = {
-            context: context,
-            guards: guards,
-            actions: actions,
-            activities: activities,
-            services: services,
-            delays: delays
-        };
-        var machineWithConfig = machine.withConfig(machineConfig, function () { return (__assign(__assign({}, machine.context), context)); });
-        return interpret(machineWithConfig, __assign({ deferEvents: true }, interpreterOptions));
-    });
-    useIsomorphicLayoutEffect(function () {
-        var sub;
-        if (observerOrListener) {
-            sub = service.subscribe(toObserver(observerOrListener));
-        }
-        return function () {
-            sub === null || sub === void 0 ? void 0 : sub.unsubscribe();
-        };
-    }, [observerOrListener]);
-    useIsomorphicLayoutEffect(function () {
-        service.start(rehydratedState ? State.create(rehydratedState) : undefined);
-        return function () {
-            service.stop();
-        };
-    }, []);
-    // 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(function () {
-        Object.assign(service.machine.options.actions, actions);
-        Object.assign(service.machine.options.guards, guards);
-        Object.assign(service.machine.options.activities, activities);
-        Object.assign(service.machine.options.services, services);
-        Object.assign(service.machine.options.delays, delays);
-    }, [actions, guards, activities, services, delays]);
-    useReactEffectActions(service);
-    return service;
-}

package/es/useMachine.d.ts

@@ -1,24 +0,0 @@
-import { ActionFunction, AreAllImplementationsAssumedToBeProvided, EventObject, InternalMachineOptions, InterpreterFrom, InterpreterOptions, StateConfig, StateFrom, StateMachine } from 'xstate';
-import { MaybeLazy, Prop, ReactActionFunction } from './types';
-export declare function asEffect<TContext, TEvent extends EventObject>(exec: ActionFunction<TContext, TEvent>): ReactActionFunction<TContext, TEvent>;
-export declare function asLayoutEffect<TContext, TEvent extends EventObject>(exec: ActionFunction<TContext, TEvent>): ReactActionFunction<TContext, TEvent>;
-export interface UseMachineOptions<TContext, 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 StateMachine<any, any, any, any, any, any, any>> = AreAllImplementationsAssumedToBeProvided<TMachine['__TResolvedTypesMeta']> extends false ? [
-    options: InterpreterOptions & UseMachineOptions<TMachine['__TContext'], TMachine['__TEvent']> & InternalMachineOptions<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta'], true>
-] : [
-    options?: InterpreterOptions & UseMachineOptions<TMachine['__TContext'], TMachine['__TEvent']> & InternalMachineOptions<TMachine['__TContext'], TMachine['__TEvent'], TMachine['__TResolvedTypesMeta']>
-];
-declare type UseMachineReturn<TMachine extends StateMachine<any, any, any, any, any, any, any>, TInterpreter = InterpreterFrom<TMachine>> = [StateFrom<TMachine>, Prop<TInterpreter, 'send'>, TInterpreter];
-export declare function useMachine<TMachine extends StateMachine<any, any, any, any, any, any, any>>(getMachine: MaybeLazy<TMachine>, ...[options]: RestParams<TMachine>): UseMachineReturn<TMachine>;
-export {};
-//# sourceMappingURL=useMachine.d.ts.map

package/es/useMachine.js

@@ -1,78 +0,0 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { useCallback, useState } from 'react';
-import { State } from 'xstate';
-import { ReactEffectType } from './types';
-import { useInterpret } from './useInterpret';
-function createReactActionFunction(exec, tag) {
-    var effectExec = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        // don't execute; just return
-        return function () {
-            return exec.apply(void 0, __spreadArray([], __read(args), false));
-        };
-    };
-    Object.defineProperties(effectExec, {
-        name: { value: "effect:".concat(exec.name) },
-        __effect: { value: tag }
-    });
-    return effectExec;
-}
-export function asEffect(exec) {
-    return createReactActionFunction(exec, ReactEffectType.Effect);
-}
-export function asLayoutEffect(exec) {
-    return createReactActionFunction(exec, ReactEffectType.LayoutEffect);
-}
-export function useMachine(getMachine) {
-    var _a = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        _a[_i - 1] = arguments[_i];
-    }
-    var _b = __read(_a, 1), _c = _b[0], options = _c === void 0 ? {} : _c;
-    var listener = useCallback(function (nextState) {
-        // Only change the current state if:
-        // - the incoming state is the "live" initial state (since it might have new actors)
-        // - OR the incoming state actually changed.
-        //
-        // The "live" initial state will have .changed === undefined.
-        var initialStateChanged = nextState.changed === undefined && Object.keys(nextState.children).length;
-        if (nextState.changed || initialStateChanged) {
-            setState(nextState);
-        }
-    }, []);
-    var service = useInterpret(getMachine, options, listener);
-    var _d = __read(useState(function () {
-        var initialState = service.machine.initialState;
-        return (options.state
-            ? State.create(options.state)
-            : initialState);
-    }), 2), state = _d[0], setState = _d[1];
-    return [state, service.send, service];
-}

package/es/useReactEffectActions.d.ts

@@ -1,3 +0,0 @@
-import { EventObject, Interpreter } from 'xstate';
-export declare function useReactEffectActions<TContext, TEvent extends EventObject>(service: Interpreter<TContext, any, TEvent, any>): void;
-//# sourceMappingURL=useReactEffectActions.d.ts.map

package/es/useReactEffectActions.js

@@ -1,76 +0,0 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { useEffect, useRef } from 'react';
-import useIsomorphicLayoutEffect from 'use-isomorphic-layout-effect';
-import { ReactEffectType } from './types';
-import { partition } from './utils';
-function executeEffect(action, state) {
-    var exec = action.exec;
-    var originalExec = exec(state.context, state._event.data, {
-        action: action,
-        state: state,
-        _event: state._event
-    });
-    originalExec();
-}
-export function useReactEffectActions(service) {
-    var effectActionsRef = useRef([]);
-    var layoutEffectActionsRef = useRef([]);
-    useIsomorphicLayoutEffect(function () {
-        var sub = service.subscribe(function (currentState) {
-            var _a, _b;
-            if (currentState.actions.length) {
-                var reactEffectActions = currentState.actions.filter(function (action) {
-                    return (typeof action.exec === 'function' &&
-                        '__effect' in action.exec);
-                });
-                var _c = __read(partition(reactEffectActions, function (action) {
-                    return action.exec.__effect === ReactEffectType.Effect;
-                }), 2), effectActions = _c[0], layoutEffectActions = _c[1];
-                (_a = effectActionsRef.current).push.apply(_a, __spreadArray([], __read(effectActions.map(function (effectAction) { return [effectAction, currentState]; })), false));
-                (_b = layoutEffectActionsRef.current).push.apply(_b, __spreadArray([], __read(layoutEffectActions.map(function (layoutEffectAction) { return [layoutEffectAction, currentState]; })), false));
-            }
-        });
-        return function () {
-            sub.unsubscribe();
-        };
-    }, []);
-    // this is somewhat weird - this should always be flushed within useLayoutEffect
-    // but we don't want to receive warnings about useLayoutEffect being used on the server
-    // so we have to use `useIsomorphicLayoutEffect` to silence those warnings
-    useIsomorphicLayoutEffect(function () {
-        while (layoutEffectActionsRef.current.length) {
-            var _a = __read(layoutEffectActionsRef.current.shift(), 2), layoutEffectAction = _a[0], effectState = _a[1];
-            executeEffect(layoutEffectAction, effectState);
-        }
-    }); // https://github.com/statelyai/xstate/pull/1202#discussion_r429677773
-    useEffect(function () {
-        while (effectActionsRef.current.length) {
-            var _a = __read(effectActionsRef.current.shift(), 2), effectAction = _a[0], effectState = _a[1];
-            executeEffect(effectAction, effectState);
-        }
-    });
-}

package/es/useSelector.d.ts

@@ -1,3 +0,0 @@
-import { ActorRef, Subscribable } from 'xstate';
-export declare function useSelector<TActor extends ActorRef<any, any>, T, TEmitted = TActor extends Subscribable<infer Emitted> ? Emitted : never>(actor: TActor, selector: (emitted: TEmitted) => T, compare?: (a: T, b: T) => boolean, getSnapshot?: (a: TActor) => TEmitted): T;
-//# sourceMappingURL=useSelector.d.ts.map

package/es/useSelector.js

@@ -1,70 +0,0 @@
-import { useMemo, useRef } from 'react';
-import { useSubscription } from 'use-subscription';
-import useIsomorphicLayoutEffect from 'use-isomorphic-layout-effect';
-import { isActorWithState } from './useActor';
-import { getServiceSnapshot } from './utils';
-function isService(actor) {
-    return 'state' in actor && 'machine' in actor;
-}
-var defaultCompare = function (a, b) { return a === b; };
-var defaultGetSnapshot = function (a) {
-    return isService(a)
-        ? getServiceSnapshot(a)
-        : isActorWithState(a)
-            ? a.state
-            : undefined;
-};
-export function useSelector(actor, selector, compare, getSnapshot) {
-    if (compare === void 0) { compare = defaultCompare; }
-    if (getSnapshot === void 0) { getSnapshot = defaultGetSnapshot; }
-    var latestSelectorRef = useRef(selector);
-    var subscription = useMemo(function () {
-        var snapshot = getSnapshot(actor);
-        var current = selector(snapshot);
-        var notifySubscriber;
-        return {
-            getSnapshot: function () { return snapshot; },
-            getCurrentValue: function () { return current; },
-            setCurrentValue: function (newCurrent) {
-                current = newCurrent;
-                notifySubscriber === null || notifySubscriber === void 0 ? void 0 : notifySubscriber();
-            },
-            subscribe: function (callback) {
-                notifySubscriber = callback;
-                var sub = actor.subscribe(function (emitted) {
-                    snapshot = emitted;
-                    var next = latestSelectorRef.current(emitted);
-                    if (!compare(current, next)) {
-                        current = next;
-                        callback();
-                    }
-                });
-                return function () {
-                    sub.unsubscribe();
-                };
-            }
-        };
-        // intentionally omit `getSnapshot` and `compare`
-        // - `getSnapshot`: it is only supposed to read the "initial" snapshot of an actor
-        // - `compare`: is really supposed to be idempotent and the same throughout the lifetime of this hook (the same assumption is made in React Redux v7)
-    }, [actor]);
-    var currentSelected = useSubscription(subscription);
-    var currentChanged = false;
-    if (latestSelectorRef.current !== selector) {
-        var selected = selector(subscription.getSnapshot());
-        if (!compare(currentSelected, selected)) {
-            currentChanged = true;
-            currentSelected = selected;
-        }
-    }
-    useIsomorphicLayoutEffect(function () {
-        latestSelectorRef.current = selector;
-        // this condition should not be required, but setState bailouts are currently buggy: https://github.com/facebook/react/issues/22654
-        if (currentChanged) {
-            // required so we don't cause a rerender by setting state (this could create infinite rerendering loop with inline selectors)
-            // at the same time we need to update the value within the subscription so new emits can compare against what has been returned to the user as current value
-            subscription.setCurrentValue(currentSelected);
-        }
-    });
-    return currentSelected;
-}

package/es/useSpawn.js

@@ -1,15 +0,0 @@
-import { spawnBehavior } from 'xstate/lib/behaviors';
-import useConstant from './useConstant';
-/**
- * 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 function useSpawn(behavior) {
-    var actorRef = useConstant(function () {
-        return spawnBehavior(behavior);
-    });
-    return actorRef;
-}

package/es/utils.d.ts

@@ -1,4 +0,0 @@
-import { Interpreter } from 'xstate';
-export declare function partition<T, A extends T, B extends T>(items: T[], predicate: (item: T) => item is A): [A[], B[]];
-export declare function getServiceSnapshot<TService extends Interpreter<any, any, any, any>>(service: TService): TService['state'];
-//# sourceMappingURL=utils.d.ts.map

package/es/utils.js

@@ -1,53 +0,0 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-export function partition(items, predicate) {
-    var e_1, _a;
-    var _b = __read([[], []], 2), truthy = _b[0], falsy = _b[1];
-    try {
-        for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
-            var item = items_1_1.value;
-            if (predicate(item)) {
-                truthy.push(item);
-            }
-            else {
-                falsy.push(item);
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    return [truthy, falsy];
-}
-export function getServiceSnapshot(service) {
-    return service.status !== 0 ? service.state : service.machine.initialState;
-}

package/lib/fsm.d.ts

@@ -1,20 +0,0 @@
-import { StateMachine, EventObject, Typestate } from '@xstate/fsm';
-export declare function useMachine<TContext extends object, TEvent extends EventObject = EventObject, TState extends Typestate<TContext> = {
-    value: any;
-    context: TContext;
-}>(stateMachine: StateMachine.Machine<TContext, TEvent, TState>, options?: {
-    actions?: StateMachine.ActionMap<TContext, TEvent>;
-}): [
-    StateMachine.State<TContext, TEvent, TState>,
-    StateMachine.Service<TContext, TEvent, TState>['send'],
-    StateMachine.Service<TContext, TEvent, TState>
-];
-export declare function useService<TContext extends object, TEvent extends EventObject = EventObject, TState extends Typestate<TContext> = {
-    value: any;
-    context: TContext;
-}>(service: StateMachine.Service<TContext, TEvent, TState>): [
-    StateMachine.State<TContext, TEvent, TState>,
-    StateMachine.Service<TContext, TEvent, TState>['send'],
-    StateMachine.Service<TContext, TEvent, TState>
-];
-//# sourceMappingURL=fsm.d.ts.map

package/lib/fsm.js

@@ -1,78 +0,0 @@
-"use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useService = exports.useMachine = void 0;
-var react_1 = require("react");
-var fsm_1 = require("@xstate/fsm");
-var use_subscription_1 = require("use-subscription");
-var useConstant_1 = require("./useConstant");
-var getServiceState = function (service) {
-    var currentValue;
-    service
-        .subscribe(function (state) {
-        currentValue = state;
-    })
-        .unsubscribe();
-    return currentValue;
-};
-function useMachine(stateMachine, options) {
-    if (process.env.NODE_ENV !== 'production') {
-        var _a = __read((0, react_1.useState)(stateMachine), 1), initialMachine = _a[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 service = (0, useConstant_1.default)(function () {
-        return (0, fsm_1.interpret)((0, fsm_1.createMachine)(stateMachine.config, options ? options : stateMachine._options)).start();
-    });
-    var _b = __read((0, react_1.useState)(function () { return getServiceState(service); }), 2), state = _b[0], setState = _b[1];
-    (0, react_1.useEffect)(function () {
-        if (options) {
-            service._machine._options = options;
-        }
-    });
-    (0, react_1.useEffect)(function () {
-        service.subscribe(setState);
-        return function () {
-            service.stop();
-        };
-    }, []);
-    return [state, service.send, service];
-}
-exports.useMachine = useMachine;
-function useService(service) {
-    var subscription = (0, react_1.useMemo)(function () {
-        var currentState = getServiceState(service);
-        return {
-            getCurrentValue: function () { return currentState; },
-            subscribe: function (callback) {
-                var unsubscribe = service.subscribe(function (state) {
-                    if (state.changed !== false) {
-                        currentState = state;
-                        callback();
-                    }
-                }).unsubscribe;
-                return unsubscribe;
-            }
-        };
-    }, [service]);
-    var state = (0, use_subscription_1.useSubscription)(subscription);
-    return [state, service.send, service];
-}
-exports.useService = useService;

package/lib/index.d.ts

@@ -1,6 +0,0 @@
-export { useMachine, asEffect, asLayoutEffect } from './useMachine';
-export { useActor } from './useActor';
-export { useInterpret } from './useInterpret';
-export { useSelector } from './useSelector';
-export { useSpawn } from './useSpawn';
-//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSpawn = exports.useSelector = exports.useInterpret = exports.useActor = exports.asLayoutEffect = exports.asEffect = exports.useMachine = void 0;
-var useMachine_1 = require("./useMachine");
-Object.defineProperty(exports, "useMachine", { enumerable: true, get: function () { return useMachine_1.useMachine; } });
-Object.defineProperty(exports, "asEffect", { enumerable: true, get: function () { return useMachine_1.asEffect; } });
-Object.defineProperty(exports, "asLayoutEffect", { enumerable: true, get: function () { return useMachine_1.asLayoutEffect; } });
-var useActor_1 = require("./useActor");
-Object.defineProperty(exports, "useActor", { enumerable: true, get: function () { return useActor_1.useActor; } });
-var useInterpret_1 = require("./useInterpret");
-Object.defineProperty(exports, "useInterpret", { enumerable: true, get: function () { return useInterpret_1.useInterpret; } });
-var useSelector_1 = require("./useSelector");
-Object.defineProperty(exports, "useSelector", { enumerable: true, get: function () { return useSelector_1.useSelector; } });
-var useSpawn_1 = require("./useSpawn");
-Object.defineProperty(exports, "useSpawn", { enumerable: true, get: function () { return useSpawn_1.useSpawn; } });

package/lib/types.d.ts

@@ -1,31 +0,0 @@
-import { ActionMeta, ActionObject, EventObject, State, 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 declare enum ReactEffectType {
-    Effect = 1,
-    LayoutEffect = 2
-}
-export interface ReactActionFunction<TContext, TEvent extends EventObject> {
-    (context: TContext, event: TEvent, meta: ActionMeta<TContext, TEvent>): () => void;
-    __effect: ReactEffectType;
-}
-export interface ReactActionObject<TContext, TEvent extends EventObject> extends ActionObject<TContext, TEvent> {
-    exec: ReactActionFunction<TContext, TEvent>;
-}
-export interface UseMachineOptions<TContext, 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>;
-}
-export declare type ActionStateTuple<TContext, TEvent extends EventObject> = [
-    ReactActionObject<TContext, TEvent>,
-    State<TContext, TEvent>
-];
-//# sourceMappingURL=types.d.ts.map

package/lib/types.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReactEffectType = void 0;
-var ReactEffectType;
-(function (ReactEffectType) {
-    ReactEffectType[ReactEffectType["Effect"] = 1] = "Effect";
-    ReactEffectType[ReactEffectType["LayoutEffect"] = 2] = "LayoutEffect";
-})(ReactEffectType = exports.ReactEffectType || (exports.ReactEffectType = {}));

package/lib/useActor.d.ts

@@ -1,9 +0,0 @@
-import { ActorRef, EventObject, Sender } from 'xstate';
-export declare function isActorWithState<T extends ActorRef<any>>(actorRef: T): actorRef is T & {
-    state: any;
-};
-declare type EmittedFromActorRef<TActor extends ActorRef<any, any>> = TActor extends ActorRef<any, infer TEmitted> ? TEmitted : never;
-export declare function useActor<TActor extends ActorRef<any, any>>(actorRef: TActor, getSnapshot?: (actor: TActor) => EmittedFromActorRef<TActor>): [EmittedFromActorRef<TActor>, TActor['send']];
-export declare function useActor<TEvent extends EventObject, TEmitted>(actorRef: ActorRef<TEvent, TEmitted>, getSnapshot?: (actor: ActorRef<TEvent, TEmitted>) => TEmitted): [TEmitted, Sender<TEvent>];
-export {};
-//# sourceMappingURL=useActor.d.ts.map