jotai/index.js

import { useLayoutEffect, useState, useRef, useEffect, useMemo, createElement, useCallback, useDebugValue } from 'react';
import { createContext, useContext, useContextSelector } from 'use-context-selector';

function _extends() {
  _extends = Object.assign || 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);
}

const isSSR = typeof window === 'undefined' || /ServerSideRendering/.test(window.navigator && window.navigator.userAgent);
const useIsoLayoutEffect = isSSR ? fn => fn() : useLayoutEffect;

const appendMap = (dst, src) => {
  src.forEach((v, k) => {
    dst.set(k, v);
  });
  return dst;
}; // create new map from two maps


const concatMap = (src1, src2) => {
  const dst = new Map();
  src1.forEach((v, k) => {
    dst.set(k, v);
  });
  src2.forEach((v, k) => {
    dst.set(k, v);
  });
  return dst;
};

const warningObject = new Proxy({}, {
  get() {
    throw new Error('Please use <Provider>');
  },

  apply() {
    throw new Error('Please use <Provider>');
  }

});

const addDependent = (dependentsMap, atom, dependent) => {
  let dependents = dependentsMap.get(atom);

  if (!dependents) {
    dependents = new Set();
    dependentsMap.set(atom, dependents);
  }

  dependents.add(dependent);
};

const deleteDependent = (dependentsMap, atom, dependent) => {
  const dependents = dependentsMap.get(atom);

  if (dependents && dependents.has(dependent)) {
    dependents.delete(dependent);
    return dependents.size === 0; // empty
  }

  return false; // not found
};

const listDependents = (dependentsMap, atom) => {
  const dependents = dependentsMap.get(atom);
  return dependents || new Set();
};

const initialState = new Map();

const getAtomStateValue = (state, atom) => {
  const atomState = state.get(atom);
  return atomState ? atomState.value : atom.init;
};

const readAtom = (state, readingAtom, setState, dependentsMap) => {
  const readAtomValue = (prevState, atom, dependent) => {
    if (dependent) {
      addDependent(dependentsMap, atom, dependent);
    }

    const partialState = new Map();
    const atomState = prevState.get(atom);

    if (atomState) {
      return [atomState, partialState];
    }

    let error = undefined;
    let promise = undefined;
    let value = null;
    let isSync = true;

    try {
      const promiseOrValue = atom.read(a => {
        if (a !== atom) {
          const [nextAtomState, nextPartialState] = readAtomValue(prevState, a, atom);

          if (isSync) {
            appendMap(partialState, nextPartialState);
          } else {
            setState(prev => appendMap(new Map(prev), nextPartialState));
          }

          if (nextAtomState.error) {
            throw nextAtomState.error;
          }

          if (nextAtomState.promise) {
            throw nextAtomState.promise;
          }

          return nextAtomState.value;
        } // primitive atom


        const aState = prevState.get(a);

        if (aState) {
          if (aState.promise) {
            throw aState.promise;
          }

          return aState.value;
        }

        return a.init; // this should not be undefined
      });

      if (promiseOrValue instanceof Promise) {
        promise = promiseOrValue.then(value => {
          setState(prev => new Map(prev).set(atom, {
            value
          }));
        }).catch(e => {
          setState(prev => new Map(prev).set(atom, {
            value: getAtomStateValue(prev, atom),
            error: e instanceof Error ? e : new Error(e)
          }));
        });
      } else {
        value = promiseOrValue;
      }
    } catch (errorOrPromise) {
      if (errorOrPromise instanceof Promise) {
        promise = errorOrPromise;
      } else if (errorOrPromise instanceof Error) {
        error = errorOrPromise;
      } else {
        error = new Error(errorOrPromise);
      }
    }

    const nextAtomState = {
      error,
      promise,
      value: promise ? atom.init : value
    };
    partialState.set(atom, nextAtomState);
    isSync = false;
    return [nextAtomState, partialState];
  };

  return readAtomValue(state, readingAtom, null);
};

const addAtom = (id, atom, partialState, setState, dependentsMap) => {
  addDependent(dependentsMap, atom, id);

  if (partialState) {
    setState(prev => appendMap(new Map(prev), partialState));
  }
};

const delAtom = (id, setState, dependentsMap, gcRequiredRef) => {
  const deleteAtomState = (prevState, dependent) => {
    prevState.forEach((_atomState, atom) => {
      deleteDependent(dependentsMap, atom, dependent);
    });
    return new Map(prevState); // to re-render
  };

  gcRequiredRef.current = true;
  setState(prev => deleteAtomState(prev, id));
};

const gcAtom = (state, setState, dependentsMap) => {
  const gcAtomState = prevState => {
    const nextState = new Map(prevState);

    while (true) {
      let deleted = false;
      nextState.forEach((_atomState, atom) => {
        var _dependentsMap$get;

        const isEmpty = ((_dependentsMap$get = dependentsMap.get(atom)) == null ? void 0 : _dependentsMap$get.size) === 0;

        if (isEmpty) {
          nextState.delete(atom);
          dependentsMap.delete(atom);
          deleted = true;
        }
      });

      if (!deleted) {
        break;
      }
    }

    return nextState;
  };

  const nextState = gcAtomState(state);

  if (state.size !== nextState.size) {
    setState(nextState);
  }
};

const writeAtom = (updatingAtom, update, dependentsMap, addWriteThunk) => {
  const updateDependentsState = (prevState, atom) => {
    const partialState = new Map();
    listDependents(dependentsMap, atom).forEach(dependent => {
      if (typeof dependent === 'symbol') return;
      const v = dependent.read(a => {
        if (a !== dependent) {
          addDependent(dependentsMap, a, dependent);
        }

        return getAtomStateValue(prevState, a);
      });

      if (v instanceof Promise) {
        const promise = v.then(vv => {
          const nextAtomState = {
            value: vv
          };
          addWriteThunk(prev => {
            const nextState = new Map(prev).set(dependent, nextAtomState);
            const nextPartialState = updateDependentsState(nextState, dependent);
            return appendMap(nextState, nextPartialState);
          });
        }).catch(e => {
          addWriteThunk(prev => new Map(prev).set(dependent, {
            value: getAtomStateValue(prev, dependent),
            error: e instanceof Error ? e : new Error(e)
          }));
        });
        partialState.set(dependent, {
          value: getAtomStateValue(prevState, dependent),
          promise
        });
      } else {
        partialState.set(dependent, {
          value: v
        });
        appendMap(partialState, updateDependentsState(concatMap(prevState, partialState), dependent));
      }
    });
    return partialState;
  };

  const updateAtomState = (prevState, atom, update) => {
    const partialState = new Map();
    let isSync = true;

    try {
      const promise = atom.write(a => getAtomStateValue(concatMap(prevState, partialState), a), (a, v) => {
        if (a === atom) {
          const nextAtomState = {
            value: v
          };

          if (isSync) {
            partialState.set(a, nextAtomState);
            appendMap(partialState, updateDependentsState(concatMap(prevState, partialState), a));
          } else {
            addWriteThunk(prev => {
              const nextState = new Map(prev).set(a, nextAtomState);
              const nextPartialState = updateDependentsState(nextState, a);
              return appendMap(nextState, nextPartialState);
            });
          }
        } else {
          if (isSync) {
            const nextPartialState = updateAtomState(prevState, a, v);
            appendMap(partialState, nextPartialState);
          } else {
            addWriteThunk(prev => {
              const nextPartialState = updateAtomState(prev, a, v);
              return appendMap(new Map(prev), nextPartialState);
            });
          }
        }
      }, update);

      if (promise instanceof Promise) {
        const nextAtomState = {
          value: getAtomStateValue(concatMap(prevState, partialState), atom),
          promise: promise.then(() => {
            addWriteThunk(prev => new Map(prev).set(atom, {
              value: getAtomStateValue(prev, atom),
              promise: undefined
            }));
          }).catch(e => {
            addWriteThunk(prev => new Map(prev).set(atom, {
              value: getAtomStateValue(prev, atom),
              error: e instanceof Error ? e : new Error(e)
            }));
          })
        };
        partialState.set(atom, nextAtomState);
      }
    } catch (e) {
      const nextAtomState = {
        value: getAtomStateValue(concatMap(prevState, partialState), atom),
        error: e instanceof Error ? e : new Error(e)
      };
      partialState.set(atom, nextAtomState);
    }

    isSync = false;
    return partialState;
  };

  addWriteThunk(prevState => {
    const updatingAtomState = prevState.get(updatingAtom);

    if (updatingAtomState && updatingAtomState.promise) {
      // schedule update after promise is resolved
      const promise = updatingAtomState.promise.then(() => {
        const updateState = updateAtomState(prevState, updatingAtom, update);
        addWriteThunk(prev => appendMap(new Map(prev), updateState));
      });
      return new Map(prevState).set(updatingAtom, _extends({}, updatingAtomState, {
        promise
      }));
    } else {
      const updateState = updateAtomState(prevState, updatingAtom, update);
      return appendMap(new Map(prevState), updateState);
    }
  });
};

const runWriteThunk = (lastStateRef, setState, writeThunkQueue) => {
  while (true) {
    if (lastStateRef.current === null) {
      return;
    }

    if (writeThunkQueue.length === 0) {
      return;
    }

    const thunk = writeThunkQueue.shift();
    const lastState = lastStateRef.current;
    const nextState = thunk(lastState);

    if (nextState !== lastState) {
      setState(nextState);
      return;
    }
  }
};

const ActionsContext = createContext(warningObject);
const StateContext = createContext(warningObject);
const Provider = ({
  children
}) => {
  const [state, setStateOrig] = useState(initialState);

  const setState = setStateAction => {
    lastStateRef.current = null;
    setStateOrig(setStateAction);
  };

  const dependentsMapRef = useRef();

  if (!dependentsMapRef.current) {
    dependentsMapRef.current = new WeakMap();
  }

  const gcRequiredRef = useRef(false);
  useEffect(() => {
    if (!gcRequiredRef.current) {
      return;
    }

    gcAtom(state, setState, dependentsMapRef.current);
    gcRequiredRef.current = false;
  }, [state]);
  const lastStateRef = useRef(null);
  useIsoLayoutEffect(() => {
    lastStateRef.current = state;
  });
  const writeThunkQueueRef = useRef([]);
  useEffect(() => {
    runWriteThunk(lastStateRef, setState, writeThunkQueueRef.current);
  }, [state]);
  const actions = useMemo(() => ({
    add: (id, atom, partialState) => addAtom(id, atom, partialState, setState, dependentsMapRef.current),
    del: id => delAtom(id, setState, dependentsMapRef.current, gcRequiredRef),
    read: (state, atom) => readAtom(state, atom, setState, dependentsMapRef.current),
    write: (atom, update) => {
      writeAtom(atom, update, dependentsMapRef.current, thunk => {
        writeThunkQueueRef.current.push(thunk);
        runWriteThunk(lastStateRef, setState, writeThunkQueueRef.current);
      });
    }
  }), []);
  return createElement(ActionsContext.Provider, {
    value: actions
  }, createElement(StateContext.Provider, {
    value: state
  }, children));
};

let keyCount = 0; // global key count for all atoms

function atom(read, write) {
  const config = {
    key: ++keyCount
  };

  if (typeof read === 'function') {
    config.read = read;
  } else {
    config.init = read;

    config.read = get => get(config);

    config.write = (get, set, update) => {
      set(config, typeof update === 'function' ? update(get(config)) : update);
    };
  }

  if (write) {
    config.write = write;
  }

  return config;
}

const isWritable = atom => !!atom.write;

function useAtom(atom) {
  const actions = useContext(ActionsContext);
  const pendingListRef = useRef([]);
  const value = useContextSelector(StateContext, useCallback(state => {
    let atomState = state.get(atom);

    if (!atomState) {
      const [initialAtomState, pendingPartialState] = actions.read(state, atom);
      atomState = initialAtomState;

      if (!atomState.error && !atomState.promise && pendingPartialState.size) {
        pendingListRef.current.unshift({
          v: initialAtomState.value,
          p: pendingPartialState
        });
      }
    }

    if (atomState.error) {
      throw atomState.error;
    }

    if (atomState.promise) {
      throw atomState.promise;
    }

    return atomState.value;
  }, [atom, actions]));
  const pendingPartialStateRef = useRef();
  useIsoLayoutEffect(() => {
    const pendingList = pendingListRef.current;
    const found = pendingList.find(({
      v
    }) => v === value);

    if (found) {
      pendingPartialStateRef.current = found.p;
    }

    pendingList.splice(0, pendingList.length);
  });
  useIsoLayoutEffect(() => {
    const id = Symbol();
    actions.add(id, atom, pendingPartialStateRef.current);
    return () => {
      actions.del(id);
    };
  }, [actions, atom]);
  const setAtom = useCallback(update => {
    if (isWritable(atom)) {
      actions.write(atom, update);
    } else {
      throw new Error('not writable atom');
    }
  }, [atom, actions]);
  useDebugValue(value);
  return [value, setAtom];
}

export { Provider, atom, useAtom };