jotai/umd/xstate.development.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('xstate'), require('jotai')) :
  typeof define === 'function' && define.amd ? define(['exports', 'xstate', 'jotai'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jotaiXstate = {}, global.xstate, global.jotai));
})(this, (function (exports, xstate, jotai) { 'use strict';

  function _extends() {
    _extends = Object.assign ? Object.assign.bind() : function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };
    return _extends.apply(this, arguments);
  }

  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];
    }

    return target;
  }

  var _excluded = ["guards", "actions", "services", "delays", "context"];
  var RESTART = Symbol();
  function atomWithMachine(getMachine, getOptions) {
    var cachedMachineAtom = jotai.atom(null);
    var machineAtom = jotai.atom(function (get) {
      var cachedMachine = get(cachedMachineAtom);

      if (cachedMachine) {
        return cachedMachine;
      }

      var initializing = true;

      var safeGet = function safeGet(a) {
        if (initializing) {
          return get(a);
        }

        throw new Error('get not allowed after initialization');
      };

      var machine = isGetter(getMachine) ? getMachine(safeGet) : getMachine;
      var options = isGetter(getOptions) ? getOptions(safeGet) : getOptions;
      initializing = false;

      var _ref = options || {},
          guards = _ref.guards,
          actions = _ref.actions,
          services = _ref.services,
          delays = _ref.delays,
          context = _ref.context,
          interpreterOptions = _objectWithoutPropertiesLoose(_ref, _excluded);

      var machineConfig = _extends({}, guards && {
        guards: guards
      }, actions && {
        actions: actions
      }, services && {
        services: services
      }, delays && {
        delays: delays
      });

      var machineWithConfig = machine.withConfig(machineConfig, function () {
        return _extends({}, machine.context, context);
      });
      var service = xstate.interpret(machineWithConfig, interpreterOptions);
      return {
        machine: machineWithConfig,
        service: service
      };
    }, function (get, set, _arg) {
      set(cachedMachineAtom, get(machineAtom));
    });

    machineAtom.onMount = function (commit) {
      commit();
    };

    var cachedMachineStateAtom = jotai.atom(null);
    var machineStateAtom = jotai.atom(function (get) {
      var _get;

      return (_get = get(cachedMachineStateAtom)) != null ? _get : get(machineAtom).machine.initialState;
    }, function (get, set, registerCleanup) {
      var _get2 = get(machineAtom),
          service = _get2.service;

      service.onTransition(function (nextState) {
        set(cachedMachineStateAtom, nextState);
      });
      service.start();
      registerCleanup(function () {
        var _get3 = get(machineAtom),
            service = _get3.service;

        service.stop();
      });
    });

    machineStateAtom.onMount = function (initialize) {
      var unsub;
      initialize(function (cleanup) {
        if (unsub === false) {
          cleanup();
        } else {
          unsub = cleanup;
        }
      });
      return function () {
        if (unsub) {
          unsub();
        }

        unsub = false;
      };
    };

    var machineStateWithServiceAtom = jotai.atom(function (get) {
      return get(machineStateAtom);
    }, function (get, set, event) {
      var _get4 = get(machineAtom),
          service = _get4.service;

      if (event === RESTART) {
        service.stop();
        set(cachedMachineAtom, null);
        set(machineAtom, null);

        var _get5 = get(machineAtom),
            newService = _get5.service;

        newService.onTransition(function (nextState) {
          set(cachedMachineStateAtom, nextState);
        });
        newService.start();
      } else {
        service.send(event);
      }
    });
    return machineStateWithServiceAtom;
  }

  var isGetter = function isGetter(v) {
    return typeof v === 'function';
  };

  exports.RESTART = RESTART;
  exports.atomWithMachine = atomWithMachine;

  Object.defineProperty(exports, '__esModule', { value: true });

}));