jotai/utils.js

import { useMemo, useCallback } from 'react';
import { atom, useAtom } from 'jotai';

const useUpdateAtom = anAtom => {
  const writeOnlyAtom = useMemo(() => atom(null, (_get, set, update) => set(anAtom, update)), [anAtom]);
  return useAtom(writeOnlyAtom)[1];
}; // -----------------------------------------------------------------------

const RESET = Symbol();
const atomWithReset = initialValue => {
  const anAtom = atom(initialValue, (get, set, update) => {
    if (update === RESET) {
      set(anAtom, initialValue);
    } else {
      set(anAtom, typeof update === 'function' ? update(get(anAtom)) : update);
    }
  });
  return anAtom;
};
const useResetAtom = anAtom => {
  const writeOnlyAtom = useMemo(() => atom(null, (_get, set, _update) => set(anAtom, RESET)), [anAtom]);
  return useAtom(writeOnlyAtom)[1];
};
function useReducerAtom(anAtom, reducer) {
  const [state, setState] = useAtom(anAtom);
  const dispatch = useCallback(action => {
    setState(prev => reducer(prev, action));
  }, [setState, reducer]);
  return [state, dispatch];
}
function atomWithReducer(initialValue, reducer) {
  const anAtom = atom(initialValue, (get, set, action) => set(anAtom, reducer(get(anAtom), action)));
  return anAtom;
}
function atomFamily(initializeRead, initializeWrite, areEqual = Object.is) {
  const atoms = [];

  const createAtom = param => {
    const found = atoms.find(x => areEqual(x[0], param));

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

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

  createAtom.remove = p => {
    const index = atoms.findIndex(x => x[0] === p);

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

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

export { atomFamily, atomWithReducer, atomWithReset, useReducerAtom, useResetAtom, useUpdateAtom };