jotai/index.cjs.js

'use strict';

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

var react = require('react');
var useContextSelector = require('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);
}

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) {
  var dst = new Map();
  src1.forEach(function (v, k) {
    dst.set(k, v);
  });
  src2.forEach(function (v, k) {
    dst.set(k, v);
  });
  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, atom, dependent) {
  var dependents = dependentsMap.get(atom);

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

  return false; // not found
};

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

var initialState = new Map();

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

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

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

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

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

    try {
      var promiseOrValue = atom.read(function (a) {
        if (a !== atom) {
          var _readAtomValue = readAtomValue(prevState, a, atom),
              _nextAtomState = _readAtomValue[0],
              nextPartialState = _readAtomValue[1];

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

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

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

          return _nextAtomState.value;
        } // primitive atom


        var 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(function (value) {
          setState(function (prev) {
            return new Map(prev).set(atom, {
              value: value
            });
          });
        }).catch(function (e) {
          setState(function (prev) {
            return 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);
      }
    }

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

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

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

  if (partialState) {
    setState(function (prev) {
      return appendMap(new Map(prev), partialState);
    });
  }
};

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

  gcRequiredRef.current = true;
  setState(function (prev) {
    return deleteAtomState(prev, id);
  });
};

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

    while (true) {
      var 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;
        }
      });

      if (!deleted) {
        break;
      }
    }

    return nextState;
  };

  var nextState = gcAtomState(state);

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

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

        return getAtomStateValue(prevState, a);
      });

      if (v instanceof Promise) {
        var promise = v.then(function (vv) {
          var nextAtomState = {
            value: vv
          };
          addWriteThunk(function (prev) {
            var nextState = new Map(prev).set(dependent, nextAtomState);
            var nextPartialState = updateDependentsState(nextState, dependent);
            return appendMap(nextState, nextPartialState);
          });
        }).catch(function (e) {
          addWriteThunk(function (prev) {
            return 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: promise
        });
      } else {
        partialState.set(dependent, {
          value: v
        });
        appendMap(partialState, updateDependentsState(concatMap(prevState, partialState), dependent));
      }
    });
    return partialState;
  };

  var updateAtomState = function updateAtomState(prevState, atom, update) {
    var partialState = new Map();
    var isSync = true;

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

          if (isSync) {
            partialState.set(a, nextAtomState);
            appendMap(partialState, updateDependentsState(concatMap(prevState, partialState), a));
          } else {
            addWriteThunk(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(prevState, a, v);
            appendMap(partialState, nextPartialState);
          } else {
            addWriteThunk(function (prev) {
              var nextPartialState = updateAtomState(prev, a, v);
              return appendMap(new Map(prev), nextPartialState);
            });
          }
        }
      }, update);

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

    isSync = false;
    return partialState;
  };

  addWriteThunk(function (prevState) {
    var updatingAtomState = prevState.get(updatingAtom);

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

var runWriteThunk = function runWriteThunk(lastStateRef, setState, writeThunkQueue) {
  while (true) {
    if (lastStateRef.current === null) {
      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 _useState = react.useState(initialState),
      state = _useState[0],
      setStateOrig = _useState[1];

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

  var dependentsMapRef = react.useRef();

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

  var gcRequiredRef = react.useRef(false);
  react.useEffect(function () {
    if (!gcRequiredRef.current) {
      return;
    }

    gcAtom(state, setState, dependentsMapRef.current);
    gcRequiredRef.current = false;
  }, [state]);
  var lastStateRef = react.useRef(null);
  useIsoLayoutEffect(function () {
    lastStateRef.current = state;
  });
  var writeThunkQueueRef = react.useRef([]);
  react.useEffect(function () {
    runWriteThunk(lastStateRef, setState, writeThunkQueueRef.current);
  }, [state]);
  var actions = react.useMemo(function () {
    return {
      add: function add(id, atom, partialState) {
        return addAtom(id, atom, partialState, setState, dependentsMapRef.current);
      },
      del: function del(id) {
        return delAtom(id, setState, dependentsMapRef.current, gcRequiredRef);
      },
      read: function read(state, atom) {
        return readAtom(state, atom, setState, dependentsMapRef.current);
      },
      write: function write(atom, update) {
        writeAtom(atom, update, 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 pendingListRef = react.useRef([]);
  var value = useContextSelector.useContextSelector(StateContext, react.useCallback(function (state) {
    var atomState = state.get(atom);

    if (!atomState) {
      var _actions$read = actions.read(state, atom),
          initialAtomState = _actions$read[0],
          pendingPartialState = _actions$read[1];

      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]));
  var pendingPartialStateRef = react.useRef();
  useIsoLayoutEffect(function () {
    var pendingList = pendingListRef.current;
    var found = pendingList.find(function (_ref) {
      var v = _ref.v;
      return v === value;
    });

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

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

exports.Provider = Provider;
exports.atom = atom;
exports.useAtom = useAtom;