jotai/index.iife.js

var jotai = (function (exports, react, useContextSelector) {
  'use strict';

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

  var isSSR = typeof window === 'undefined' || /ServerSideRendering/.test(window.navigator && window.navigator.userAgent);
  var useIsoLayoutEffect = isSSR ? function (fn) {
    return fn();
  } : react.useLayoutEffect;

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


  var concatMap = function concatMap(src1, src2) {
    return appendMap(new Map(src1), src2);
  }; // create new map and delete item


  var deleteMapItem = function deleteMapItem(src, key) {
    var dst = new Map(src);
    dst.delete(key);
    return dst;
  };

  var warningObject = new Proxy({}, {
    get: function get() {
      throw new Error('Please use <Provider>');
    },
    apply: function apply() {
      throw new Error('Please use <Provider>');
    }
  });

  var addDependent = function addDependent(dependentsMap, atom, dependent) {
    var dependents = dependentsMap.get(atom);

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

    dependents.add(dependent);
  };

  var deleteDependent = function deleteDependent(dependentsMap, dependent) {
    dependentsMap.forEach(function (dependents) {
      dependents.delete(dependent);
    });
  };

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

  var listDependents = function listDependents(dependentsMap, atom, excludeSelf) {
    var dependents = new Set(dependentsMap.get(atom));

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

    return dependents;
  };

  var initialState = new Map();

  var getAtomState = function getAtomState(atom, state, tmpState) {
    var atomState = tmpState && tmpState.get(atom) || state.get(atom);

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

    return atomState;
  };

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

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

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

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

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

          if (a !== atom) {
            var _readAtomValue = readAtomValue(concatMap(prevState, partialState), a),
                _nextAtomState = _readAtomValue[0],
                nextPartialState = _readAtomValue[1];

            if (isSync) {
              appendMap(partialState, nextPartialState);
            } else {
              setState(function (prev) {
                return concatMap(prev, nextPartialState);
              });
            }

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

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

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


          var 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(function (value) {
            var _prev$get;

            setDependencies(dependentsMap, atom, dependencies);
            dependencies = null;
            var 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(function (prev) {
              return new Map(prev).set(atom, {
                value: value
              });
            });
          }).catch(function (e) {
            var _prev$get2;

            var 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(function (prev) {
              return 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);
        }
      }

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

    var prevPartialState = readPendingMap.get(readingAtom);

    var _readAtomValue2 = readAtomValue(prevPartialState ? concatMap(state, prevPartialState) : state, readingAtom),
        atomState = _readAtomValue2[0],
        partialState = _readAtomValue2[1];

    readPendingMap.set(readingAtom, prevPartialState ? concatMap(prevPartialState, partialState) : partialState);
    return atomState;
  };

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

    if (partialState) {
      readPendingMap.delete(atom);
      setState(function (prev) {
        return concatMap(prev, partialState);
      });
    }
  };

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

  var gcAtom = function gcAtom(state, setState, dependentsMap) {
    var nextState = new Map(state);
    var deleted;

    do {
      deleted = false;
      nextState.forEach(function (_atomState, atom) {
        var _dependentsMap$get;

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

  var writeAtom = function writeAtom(updatingAtom, update, setState, dependentsMap, addWriteThunk) {
    var pendingPromises = [];

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

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

            var s = getAtomState(a, prevState);

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

            return s.value;
          });

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

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

                var nextState = new Map(prev).set(dependent, nextAtomState);
                var nextPartialState = updateDependentsState(nextState, dependent);
                return appendMap(nextState, nextPartialState);
              });
            }).catch(function (e) {
              setState(function (prev) {
                return 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;
    };

    var updateAtomState = function updateAtomState(prevState, atom, update) {
      var prevAtomState = prevState.get(atom);

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

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

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

      var partialState = new Map();
      var isSync = true;

      try {
        var promiseOrVoid = atom.write(function (a) {
          if (process.env.NODE_ENV !== 'production') {
            var 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);
        }, function (a, v) {
          if (a === atom) {
            var nextAtomState = {
              value: v
            };

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

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

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

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

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

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

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

      isSync = false;
      return partialState;
    };

    addWriteThunk(function (prevState) {
      var nextPartialState = updateAtomState(prevState, updatingAtom, update);

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

      return prevState;
    });

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

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

        loop();
      });
    }
  };

  var runWriteThunk = function runWriteThunk(lastStateRef, setState, writeThunkQueue) {
    while (true) {
      if (!lastStateRef.current) {
        return;
      }

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

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

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

  var ActionsContext = useContextSelector.createContext(warningObject);
  var StateContext = useContextSelector.createContext(warningObject);
  var Provider = function Provider(_ref) {
    var children = _ref.children;
    var dependentsMapRef = react.useRef();

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

    var readPendingMapRef = react.useRef();

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

    var _useState = react.useState(initialState),
        state = _useState[0],
        setStateOrig = _useState[1];

    var lastStateRef = react.useRef(null);

    var setState = function setState(setStateAction) {
      lastStateRef.current = null;
      setStateOrig(setStateAction);
    };

    useIsoLayoutEffect(function () {
      if (state !== initialState) {
        lastStateRef.current = state;
      }
    });

    var _useState2 = react.useState(0),
        gcCount = _useState2[0],
        setGcCount = _useState2[1]; // to trigger gc


    react.useEffect(function () {
      gcAtom(state, setState, dependentsMapRef.current);
    }, [state, gcCount]);
    var writeThunkQueueRef = react.useRef([]);
    react.useEffect(function () {
      runWriteThunk(lastStateRef, setState, writeThunkQueueRef.current);
    }, [state]);
    var actions = react.useMemo(function () {
      return {
        add: function add(id, atom) {
          return addAtom(id, atom, setState, dependentsMapRef.current, readPendingMapRef.current);
        },
        del: function del(id) {
          return delAtom(id, setGcCount, dependentsMapRef.current);
        },
        read: function read(state, atom) {
          return readAtom(state, atom, setState, dependentsMapRef.current, readPendingMapRef.current);
        },
        write: function write(atom, update) {
          return writeAtom(atom, update, setState, dependentsMapRef.current, function (thunk) {
            writeThunkQueueRef.current.push(thunk);
            runWriteThunk(lastStateRef, setState, writeThunkQueueRef.current);
          });
        }
      };
    }, []);
    return react.createElement(ActionsContext.Provider, {
      value: actions
    }, react.createElement(StateContext.Provider, {
      value: state
    }, children));
  };

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

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

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

      config.read = function (get) {
        return get(config);
      };

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

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

    return config;
  }

  var isWritable = function isWritable(atom) {
    return !!atom.write;
  };

  function useAtom(atom) {
    var actions = useContextSelector.useContext(ActionsContext);
    var value = useContextSelector.useContextSelector(StateContext, react.useCallback(function (state) {
      var 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(function () {
      var id = Symbol();
      actions.add(id, atom);
      return function () {
        actions.del(id);
      };
    }, [actions, atom]);
    var setAtom = react.useCallback(function (update) {
      if (isWritable(atom)) {
        return actions.write(atom, update);
      } else {
        throw new Error('not writable atom');
      }
    }, [atom, actions]);
    react.useDebugValue(value);
    return [value, setAtom];
  }

  var useBridge = function useBridge() {
    var actions = useContextSelector.useContext(ActionsContext);
    var state = useContextSelector.useContext(StateContext);
    return react.useMemo(function () {
      return [actions, state];
    }, [actions, state]);
  };
  var Bridge = function Bridge(_ref) {
    var value = _ref.value,
        children = _ref.children;
    var actions = value[0],
        state = value[1];
    return react.createElement(useContextSelector.BridgeProvider, {
      context: ActionsContext,
      value: actions
    }, react.createElement(useContextSelector.BridgeProvider, {
      context: StateContext,
      value: state
    }, children));
  };

  exports.Bridge = Bridge;
  exports.Provider = Provider;
  exports.atom = atom;
  exports.useAtom = useAtom;
  exports.useBridge = useBridge;

  return exports;

}({}, React, useContextSelector));