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