jotai/esm/xstate.mjs

import { interpret } from 'xstate';
import { atom } from 'jotai';

const RESTART = Symbol();
function atomWithMachine(getMachine, getOptions) {
  const cachedMachineAtom = atom(null);
  const machineAtom = atom((get) => {
    const cachedMachine = get(cachedMachineAtom);
    if (cachedMachine) {
      return cachedMachine;
    }
    let initializing = true;
    const safeGet = (a) => {
      if (initializing) {
        return get(a);
      }
      throw new Error("get not allowed after initialization");
    };
    const machine = isGetter(getMachine) ? getMachine(safeGet) : getMachine;
    const options = isGetter(getOptions) ? getOptions(safeGet) : getOptions;
    initializing = false;
    const {
      guards,
      actions,
      services,
      delays,
      context,
      ...interpreterOptions
    } = options || {};
    const machineConfig = {
      ...guards && { guards },
      ...actions && { actions },
      ...services && { services },
      ...delays && { delays }
    };
    const machineWithConfig = machine.withConfig(machineConfig, () => ({
      ...machine.context,
      ...context
    }));
    const service = interpret(machineWithConfig, interpreterOptions);
    return { machine: machineWithConfig, service };
  }, (get, set, _arg) => {
    set(cachedMachineAtom, get(machineAtom));
  });
  machineAtom.onMount = (commit) => {
    commit();
  };
  const cachedMachineStateAtom = atom(null);
  const machineStateAtom = atom((get) => {
    var _a;
    return (_a = get(cachedMachineStateAtom)) != null ? _a : get(machineAtom).machine.initialState;
  }, (get, set, registerCleanup) => {
    const { service } = get(machineAtom);
    service.onTransition((nextState) => {
      set(cachedMachineStateAtom, nextState);
    });
    service.start();
    registerCleanup(() => {
      const { service: service2 } = get(machineAtom);
      service2.stop();
    });
  });
  machineStateAtom.onMount = (initialize) => {
    let unsub;
    initialize((cleanup) => {
      if (unsub === false) {
        cleanup();
      } else {
        unsub = cleanup;
      }
    });
    return () => {
      if (unsub) {
        unsub();
      }
      unsub = false;
    };
  };
  const machineStateWithServiceAtom = atom((get) => get(machineStateAtom), (get, set, event) => {
    const { service } = get(machineAtom);
    if (event === RESTART) {
      service.stop();
      set(cachedMachineAtom, null);
      set(machineAtom, null);
      const { service: newService } = get(machineAtom);
      newService.onTransition((nextState) => {
        set(cachedMachineStateAtom, nextState);
      });
      newService.start();
    } else {
      service.send(event);
    }
  });
  return machineStateWithServiceAtom;
}
const isGetter = (v) => typeof v === "function";

export { RESTART, atomWithMachine };