jotai/utils.cjs.js

'use strict';

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

var react = require('react');
var jotai = require('jotai');

var useUpdateAtom = function useUpdateAtom(anAtom) {
  var writeOnlyAtom = react.useMemo(function () {
    return jotai.atom(null, function (_get, set, update) {
      return set(anAtom, update);
    });
  }, [anAtom]);
  return jotai.useAtom(writeOnlyAtom)[1];
}; // -----------------------------------------------------------------------

var RESET = Symbol();
var atomWithReset = function atomWithReset(initialValue) {
  var anAtom = jotai.atom(initialValue, function (get, set, update) {
    if (update === RESET) {
      set(anAtom, initialValue);
    } else {
      set(anAtom, typeof update === 'function' ? update(get(anAtom)) : update);
    }
  });
  return anAtom;
};
var useResetAtom = function useResetAtom(anAtom) {
  var writeOnlyAtom = react.useMemo(function () {
    return jotai.atom(null, function (_get, set, _update) {
      return set(anAtom, RESET);
    });
  }, [anAtom]);
  return jotai.useAtom(writeOnlyAtom)[1];
};
function useReducerAtom(anAtom, reducer) {
  var _useAtom = jotai.useAtom(anAtom),
      state = _useAtom[0],
      setState = _useAtom[1];

  var dispatch = react.useCallback(function (action) {
    setState(function (prev) {
      return reducer(prev, action);
    });
  }, [setState, reducer]);
  return [state, dispatch];
}
function atomWithReducer(initialValue, reducer) {
  var anAtom = jotai.atom(initialValue, function (get, set, action) {
    return set(anAtom, reducer(get(anAtom), action));
  });
  return anAtom;
}
function atomFamily(initializeRead, initializeWrite, areEqual) {
  if (areEqual === void 0) {
    areEqual = Object.is;
  }

  var atoms = [];

  var createAtom = function createAtom(param) {
    var found = atoms.find(function (x) {
      return areEqual(x[0], param);
    });

    if (found) {
      return found[1];
    }

    var newAtom = jotai.atom(initializeRead(param), initializeWrite && initializeWrite(param));
    atoms.unshift([param, newAtom]);
    return newAtom;
  };

  createAtom.remove = function (p) {
    var index = atoms.findIndex(function (x) {
      return x[0] === p;
    });

    if (index >= 0) {
      atoms.splice(index, 1);
    }
  };

  return createAtom;
} // -----------------------------------------------------------------------

exports.atomFamily = atomFamily;
exports.atomWithReducer = atomWithReducer;
exports.atomWithReset = atomWithReset;
exports.useReducerAtom = useReducerAtom;
exports.useResetAtom = useResetAtom;
exports.useUpdateAtom = useUpdateAtom;