jotai/index.js

import { useLayoutEffect, useRef, useState, useEffect, useMemo, createElement, useCallback, useDebugValue } from 'react';
import { createContext, useContext, useContextSelector, BridgeProvider } 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) => appendMap(new Map(src1), src2); // create new map and delete item


const deleteMapItem = (src, key) => {
  const dst = new Map(src);
  dst.delete(key);
  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, dependent) => {
  dependentsMap.forEach(dependents => {
    dependents.delete(dependent);
  });
};

const setDependencies = (dependentsMap, atom, dependencies) => {
  deleteDependent(dependentsMap, atom);
  dependencies.forEach(dependency => {
    addDependent(dependentsMap, dependency, atom);
  });
};

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

  if (excludeSelf) {
    dependents.delete(atom);
  }

  return dependents;
};

const initialState = new Map();

const getAtomState = (atom, state, tmpState) => {
  const atomState = tmpState && tmpState.get(atom) || state.get(atom);

  if (!atomState) {
    throw new Error('atom state not found. possibly a bug.');
  }

  return atomState;
};

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

const readAtom = (state, readingAtom, setState, dependentsMap, readPendingMap) => {
  const readAtomValue = (prevState, atom) => {
    const partialState = new Map();
    const atomState = prevState.get(atom);

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

    let error = undefined;
    let promise = undefined;
    let value = null;
    let dependencies = new Set();
    let isSync = true;

    try {
      const promiseOrValue = atom.read(a => {
        if (dependencies) {
          dependencies.add(a);
        } else {
          addDependent(dependentsMap, a, atom);
        }

        if (a !== atom) {
          const [nextAtomState, nextPartialState] = readAtomValue(concatMap(prevState, partialState), a);

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

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

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

          return nextAtomState.value;
        } // a === atom


        const aState = partialState.get(a) || prevState.get(a);

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

          return aState.value;
        }

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

      if (promiseOrValue instanceof Promise) {
        promise = promiseOrValue.then(value => {
          var _prev$get;

          setDependencies(dependentsMap, atom, dependencies);
          dependencies = null;
          const prev = readPendingMap.get(atom);

          if (prev && ((_prev$get = prev.get(atom)) == null ? void 0 : _prev$get.readP) === promise) {
            readPendingMap.set(atom, deleteMapItem(prev, atom));
          }

          setState(prev => new Map(prev).set(atom, {
            value
          }));
        }).catch(e => {
          var _prev$get2;

          const prev = readPendingMap.get(atom);

          if (prev && ((_prev$get2 = prev.get(atom)) == null ? void 0 : _prev$get2.readP) === promise) {
            readPendingMap.set(atom, deleteMapItem(prev, atom));
          }

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

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

  const prevPartialState = readPendingMap.get(readingAtom);
  const [atomState, partialState] = readAtomValue(prevPartialState ? concatMap(state, prevPartialState) : state, readingAtom);
  readPendingMap.set(readingAtom, prevPartialState ? concatMap(prevPartialState, partialState) : partialState);
  return atomState;
};

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

  if (partialState) {
    readPendingMap.delete(atom);
    setState(prev => concatMap(prev, partialState));
  }
};

const delAtom = (id, setGcCount, dependentsMap) => {
  deleteDependent(dependentsMap, id);
  setGcCount(c => c + 1); // trigger re-render for gc
};

const gcAtom = (state, setState, dependentsMap) => {
  const nextState = new Map(state);
  let deleted;

  do {
    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;
      }
    });
  } while (deleted);

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

const writeAtom = (updatingAtom, update, setState, dependentsMap, addWriteThunk) => {
  const pendingPromises = [];

  const updateDependentsState = (prevState, atom) => {
    const partialState = new Map();
    listDependents(dependentsMap, atom, true).forEach(dependent => {
      if (typeof dependent === 'symbol') return;
      let dependencies = new Set();

      try {
        const promiseOrValue = dependent.read(a => {
          if (dependencies) {
            dependencies.add(a);
          } else {
            addDependent(dependentsMap, a, dependent);
          }

          const s = getAtomState(a, prevState);

          if (s.readE) {
            throw s.readE;
          }

          return s.value;
        });

        if (promiseOrValue instanceof Promise) {
          const promise = promiseOrValue.then(value => {
            setDependencies(dependentsMap, dependent, dependencies);
            dependencies = null;
            const nextAtomState = {
              value
            };
            setState(prev => {
              var _prev$get3;

              const prevPromise = (_prev$get3 = prev.get(dependent)) == null ? void 0 : _prev$get3.readP;

              if (prevPromise && prevPromise !== promise) {
                // There is a new promise, so we skip updating this one.
                return prev;
              }

              const nextState = new Map(prev).set(dependent, nextAtomState);
              const nextPartialState = updateDependentsState(nextState, dependent);
              return appendMap(nextState, nextPartialState);
            });
          }).catch(e => {
            setState(prev => new Map(prev).set(dependent, {
              value: getAtomStateValue(dependent, prev),
              readE: e instanceof Error ? e : new Error(e)
            }));
          });
          partialState.set(dependent, {
            value: getAtomStateValue(dependent, prevState),
            readP: promise
          });
        } else {
          setDependencies(dependentsMap, dependent, dependencies);
          dependencies = null;
          partialState.set(dependent, {
            value: promiseOrValue
          });
          appendMap(partialState, updateDependentsState(concatMap(prevState, partialState), dependent));
        }
      } catch (e) {
        partialState.set(dependent, {
          value: getAtomStateValue(dependent, prevState),
          readE: e instanceof Error ? e : new Error(e)
        });
        appendMap(partialState, updateDependentsState(concatMap(prevState, partialState), dependent));
      }
    });
    return partialState;
  };

  const updateAtomState = (prevState, atom, update) => {
    const prevAtomState = prevState.get(atom);

    if (prevAtomState && prevAtomState.writeP) {
      const promise = prevAtomState.writeP.then(() => {
        addWriteThunk(prev => {
          const nextPartialState = updateAtomState(prev, atom, update);

          if (nextPartialState) {
            return concatMap(prevState, nextPartialState);
          }

          return prev;
        });
      });
      pendingPromises.push(promise);
      return null;
    }

    const partialState = new Map();
    let isSync = true;

    try {
      const promiseOrVoid = atom.write(a => {
        if (process.env.NODE_ENV !== 'production') {
          const s = prevState.get(a);

          if (s && s.readP) {
            console.log('Reading pending atom state in write operation. Not sure how to deal with it. Returning stale vaule for', a);
          }
        }

        return getAtomStateValue(a, prevState, partialState);
      }, (a, v) => {
        if (a === atom) {
          const nextAtomState = {
            value: v
          };

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

            if (nextPartialState) {
              appendMap(partialState, nextPartialState);
            }
          } else {
            addWriteThunk(prev => {
              const nextPartialState = updateAtomState(prev, a, v);

              if (nextPartialState) {
                return concatMap(prev, nextPartialState);
              }

              return prev;
            });
          }
        }
      }, update);

      if (promiseOrVoid instanceof Promise) {
        pendingPromises.push(promiseOrVoid);

        const nextAtomState = _extends({}, getAtomState(atom, prevState, partialState), {
          writeP: promiseOrVoid.then(() => {
            addWriteThunk(prev => new Map(prev).set(atom, _extends({}, getAtomState(atom, prev), {
              writeP: undefined
            })));
          })
        });

        partialState.set(atom, nextAtomState);
      }
    } catch (e) {
      if (pendingPromises.length) {
        pendingPromises.push(new Promise((_resolve, reject) => {
          reject(e);
        }));
      } else {
        throw e;
      }
    }

    isSync = false;
    return partialState;
  };

  addWriteThunk(prevState => {
    const nextPartialState = updateAtomState(prevState, updatingAtom, update);

    if (nextPartialState) {
      return concatMap(prevState, nextPartialState);
    }

    return prevState;
  });

  if (pendingPromises.length) {
    return new Promise((resolve, reject) => {
      const loop = () => {
        const len = pendingPromises.length;

        if (len === 0) {
          resolve();
        } else {
          Promise.all(pendingPromises).then(() => {
            pendingPromises.splice(0, len);
            loop();
          }).catch(reject);
        }
      };

      loop();
    });
  }
};

const runWriteThunk = (lastStateRef, setState, writeThunkQueue) => {
  while (true) {
    if (!lastStateRef.current) {
      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 dependentsMapRef = useRef();

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

  const readPendingMapRef = useRef();

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

  const [state, setStateOrig] = useState(initialState);
  const lastStateRef = useRef(null);

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

  useIsoLayoutEffect(() => {
    if (state !== initialState) {
      lastStateRef.current = state;
    }
  });
  const [gcCount, setGcCount] = useState(0); // to trigger gc

  useEffect(() => {
    gcAtom(state, setState, dependentsMapRef.current);
  }, [state, gcCount]);
  const writeThunkQueueRef = useRef([]);
  useEffect(() => {
    runWriteThunk(lastStateRef, setState, writeThunkQueueRef.current);
  }, [state]);
  const actions = useMemo(() => ({
    add: (id, atom) => addAtom(id, atom, setState, dependentsMapRef.current, readPendingMapRef.current),
    del: id => delAtom(id, setGcCount, dependentsMapRef.current),
    read: (state, atom) => readAtom(state, atom, setState, dependentsMapRef.current, readPendingMapRef.current),
    write: (atom, update) => writeAtom(atom, update, setState, 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 value = useContextSelector(StateContext, useCallback(state => {
    const atomState = actions.read(state, atom);

    if (atomState.readE) {
      throw atomState.readE; // read error
    }

    if (atomState.readP) {
      throw atomState.readP; // read promise
    }

    if (atomState.writeP) {
      throw atomState.writeP; // write promise
    }

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

const useBridge = () => {
  const actions = useContext(ActionsContext);
  const state = useContext(StateContext);
  return useMemo(() => [actions, state], [actions, state]);
};
const Bridge = ({
  value,
  children
}) => {
  const [actions, state] = value;
  return createElement(BridgeProvider, {
    context: ActionsContext,
    value: actions
  }, createElement(BridgeProvider, {
    context: StateContext,
    value: state
  }, children));
};

export { Bridge, Provider, atom, useAtom, useBridge };