726 lines
25 KiB
JavaScript
726 lines
25 KiB
JavaScript
'use strict';
|
|
|
|
function _arrayLikeToArray(r, a) {
|
|
(null == a || a > r.length) && (a = r.length);
|
|
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
|
|
return n;
|
|
}
|
|
function _createForOfIteratorHelperLoose(r, e) {
|
|
var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
|
|
if (t) return (t = t.call(r)).next.bind(t);
|
|
if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
|
|
t && (r = t);
|
|
var o = 0;
|
|
return function () {
|
|
return o >= r.length ? {
|
|
done: true
|
|
} : {
|
|
done: false,
|
|
value: r[o++]
|
|
};
|
|
};
|
|
}
|
|
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
function _unsupportedIterableToArray(r, a) {
|
|
if (r) {
|
|
if ("string" == typeof r) return _arrayLikeToArray(r, a);
|
|
var t = {}.toString.call(r).slice(8, -1);
|
|
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
|
|
}
|
|
}
|
|
|
|
function hasInitialValue(atom) {
|
|
return 'init' in atom;
|
|
}
|
|
function isActuallyWritableAtom(atom) {
|
|
return !!atom.write;
|
|
}
|
|
function isAtomStateInitialized(atomState) {
|
|
return 'v' in atomState || 'e' in atomState;
|
|
}
|
|
function returnAtomValue(atomState) {
|
|
if ('e' in atomState) {
|
|
throw atomState.e;
|
|
}
|
|
if (process.env.NODE_ENV !== 'production' && !('v' in atomState)) {
|
|
throw new Error('[Bug] atom state is not initialized');
|
|
}
|
|
return atomState.v;
|
|
}
|
|
var promiseStateMap = new WeakMap();
|
|
function isPendingPromise(value) {
|
|
var _promiseStateMap$get;
|
|
return isPromiseLike(value) && !!((_promiseStateMap$get = promiseStateMap.get(value)) != null && _promiseStateMap$get[0]);
|
|
}
|
|
function abortPromise(promise) {
|
|
var promiseState = promiseStateMap.get(promise);
|
|
if (promiseState != null && promiseState[0]) {
|
|
promiseState[0] = false;
|
|
promiseState[1].forEach(function (fn) {
|
|
return fn();
|
|
});
|
|
}
|
|
}
|
|
function registerAbortHandler(promise, abortHandler) {
|
|
var promiseState = promiseStateMap.get(promise);
|
|
if (!promiseState) {
|
|
promiseState = [true, new Set()];
|
|
promiseStateMap.set(promise, promiseState);
|
|
var settle = function settle() {
|
|
promiseState[0] = false;
|
|
};
|
|
promise.then(settle, settle);
|
|
}
|
|
promiseState[1].add(abortHandler);
|
|
}
|
|
function isPromiseLike(p) {
|
|
return typeof (p == null ? void 0 : p.then) === 'function';
|
|
}
|
|
function addPendingPromiseToDependency(atom, promise, dependencyAtomState) {
|
|
if (!dependencyAtomState.p.has(atom)) {
|
|
dependencyAtomState.p.add(atom);
|
|
var cleanup = function cleanup() {
|
|
return dependencyAtomState.p.delete(atom);
|
|
};
|
|
promise.then(cleanup, cleanup);
|
|
}
|
|
}
|
|
function getMountedOrPendingDependents(atom, atomState, mountedMap) {
|
|
var dependents = new Set();
|
|
for (var _iterator = _createForOfIteratorHelperLoose(((_mountedMap$get = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get.t) || []), _step; !(_step = _iterator()).done;) {
|
|
var _mountedMap$get;
|
|
var a = _step.value;
|
|
if (mountedMap.has(a)) {
|
|
dependents.add(a);
|
|
}
|
|
}
|
|
for (var _iterator2 = _createForOfIteratorHelperLoose(atomState.p), _step2; !(_step2 = _iterator2()).done;) {
|
|
var atomWithPendingPromise = _step2.value;
|
|
dependents.add(atomWithPendingPromise);
|
|
}
|
|
return dependents;
|
|
}
|
|
var createStoreHook = function createStoreHook() {
|
|
var callbacks = new Set();
|
|
var notify = function notify() {
|
|
return callbacks.forEach(function (fn) {
|
|
return fn();
|
|
});
|
|
};
|
|
notify.add = function (fn) {
|
|
callbacks.add(fn);
|
|
return function () {
|
|
return callbacks.delete(fn);
|
|
};
|
|
};
|
|
return notify;
|
|
};
|
|
var createStoreHookForAtoms = function createStoreHookForAtoms() {
|
|
var all = {};
|
|
var callbacks = new WeakMap();
|
|
var notify = function notify(atom) {
|
|
var _callbacks$get, _callbacks$get2;
|
|
(_callbacks$get = callbacks.get(all)) == null || _callbacks$get.forEach(function (fn) {
|
|
return fn(atom);
|
|
});
|
|
(_callbacks$get2 = callbacks.get(atom)) == null || _callbacks$get2.forEach(function (fn) {
|
|
return fn();
|
|
});
|
|
};
|
|
notify.add = function (atom, fn) {
|
|
var key = atom || all;
|
|
var fns = (callbacks.has(key) ? callbacks : callbacks.set(key, new Set())).get(key);
|
|
fns.add(fn);
|
|
return function () {
|
|
fns == null || fns.delete(fn);
|
|
if (!fns.size) {
|
|
callbacks.delete(key);
|
|
}
|
|
};
|
|
};
|
|
return notify;
|
|
};
|
|
function initializeStoreHooks(storeHooks) {
|
|
var _ref, _ref2, _ref3, _ref4, _ref5;
|
|
(_ref = storeHooks).r || (_ref.r = createStoreHookForAtoms());
|
|
(_ref2 = storeHooks).c || (_ref2.c = createStoreHookForAtoms());
|
|
(_ref3 = storeHooks).m || (_ref3.m = createStoreHookForAtoms());
|
|
(_ref4 = storeHooks).u || (_ref4.u = createStoreHookForAtoms());
|
|
(_ref5 = storeHooks).f || (_ref5.f = createStoreHook());
|
|
return storeHooks;
|
|
}
|
|
var atomRead = function atomRead(_store, atom) {
|
|
for (var _len = arguments.length, params = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
|
|
params[_key - 2] = arguments[_key];
|
|
}
|
|
return atom.read.apply(atom, params);
|
|
};
|
|
var atomWrite = function atomWrite(_store, atom) {
|
|
for (var _len2 = arguments.length, params = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
|
|
params[_key2 - 2] = arguments[_key2];
|
|
}
|
|
return atom.write.apply(atom, params);
|
|
};
|
|
var atomOnInit = function atomOnInit(store, atom) {
|
|
return atom.unstable_onInit == null ? void 0 : atom.unstable_onInit(store);
|
|
};
|
|
var atomOnMount = function atomOnMount(_store, atom, setAtom) {
|
|
return atom.onMount == null ? void 0 : atom.onMount(setAtom);
|
|
};
|
|
var ensureAtomState = function ensureAtomState(store, atom) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var atomStateMap = buildingBlocks[0];
|
|
var atomOnInit = buildingBlocks[9];
|
|
if (process.env.NODE_ENV !== 'production' && !atom) {
|
|
throw new Error('Atom is undefined or null');
|
|
}
|
|
var atomState = atomStateMap.get(atom);
|
|
if (!atomState) {
|
|
atomState = {
|
|
d: new Map(),
|
|
p: new Set(),
|
|
n: 0
|
|
};
|
|
atomStateMap.set(atom, atomState);
|
|
atomOnInit == null || atomOnInit(store, atom);
|
|
}
|
|
return atomState;
|
|
};
|
|
var flushCallbacks = function flushCallbacks(store) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var mountedMap = buildingBlocks[1];
|
|
var changedAtoms = buildingBlocks[3];
|
|
var mountCallbacks = buildingBlocks[4];
|
|
var unmountCallbacks = buildingBlocks[5];
|
|
var storeHooks = buildingBlocks[6];
|
|
var recomputeInvalidatedAtoms = buildingBlocks[13];
|
|
var errors = [];
|
|
var call = function call(fn) {
|
|
try {
|
|
fn();
|
|
} catch (e) {
|
|
errors.push(e);
|
|
}
|
|
};
|
|
var _loop = function _loop() {
|
|
if (storeHooks.f) {
|
|
call(storeHooks.f);
|
|
}
|
|
var callbacks = new Set();
|
|
var add = callbacks.add.bind(callbacks);
|
|
changedAtoms.forEach(function (atom) {
|
|
var _mountedMap$get2;
|
|
return (_mountedMap$get2 = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get2.l.forEach(add);
|
|
});
|
|
changedAtoms.clear();
|
|
unmountCallbacks.forEach(add);
|
|
unmountCallbacks.clear();
|
|
mountCallbacks.forEach(add);
|
|
mountCallbacks.clear();
|
|
callbacks.forEach(call);
|
|
if (changedAtoms.size) {
|
|
recomputeInvalidatedAtoms(store);
|
|
}
|
|
};
|
|
do {
|
|
_loop();
|
|
} while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
|
|
if (errors.length) {
|
|
throw new AggregateError(errors);
|
|
}
|
|
};
|
|
var recomputeInvalidatedAtoms = function recomputeInvalidatedAtoms(store) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var mountedMap = buildingBlocks[1];
|
|
var invalidatedAtoms = buildingBlocks[2];
|
|
var changedAtoms = buildingBlocks[3];
|
|
var ensureAtomState = buildingBlocks[11];
|
|
var readAtomState = buildingBlocks[14];
|
|
var mountDependencies = buildingBlocks[17];
|
|
var topSortedReversed = [];
|
|
var visiting = new WeakSet();
|
|
var visited = new WeakSet();
|
|
var stack = Array.from(changedAtoms);
|
|
while (stack.length) {
|
|
var a = stack[stack.length - 1];
|
|
var aState = ensureAtomState(store, a);
|
|
if (visited.has(a)) {
|
|
stack.pop();
|
|
continue;
|
|
}
|
|
if (visiting.has(a)) {
|
|
if (invalidatedAtoms.get(a) === aState.n) {
|
|
topSortedReversed.push([a, aState]);
|
|
} else if (process.env.NODE_ENV !== 'production' && invalidatedAtoms.has(a)) {
|
|
throw new Error('[Bug] invalidated atom exists');
|
|
}
|
|
visited.add(a);
|
|
stack.pop();
|
|
continue;
|
|
}
|
|
visiting.add(a);
|
|
for (var _iterator3 = _createForOfIteratorHelperLoose(getMountedOrPendingDependents(a, aState, mountedMap)), _step3; !(_step3 = _iterator3()).done;) {
|
|
var d = _step3.value;
|
|
if (!visiting.has(d)) {
|
|
stack.push(d);
|
|
}
|
|
}
|
|
}
|
|
for (var i = topSortedReversed.length - 1; i >= 0; --i) {
|
|
var _ref6 = topSortedReversed[i],
|
|
_a = _ref6[0],
|
|
_aState = _ref6[1];
|
|
var hasChangedDeps = false;
|
|
for (var _iterator4 = _createForOfIteratorHelperLoose(_aState.d.keys()), _step4; !(_step4 = _iterator4()).done;) {
|
|
var dep = _step4.value;
|
|
if (dep !== _a && changedAtoms.has(dep)) {
|
|
hasChangedDeps = true;
|
|
break;
|
|
}
|
|
}
|
|
if (hasChangedDeps) {
|
|
readAtomState(store, _a);
|
|
mountDependencies(store, _a);
|
|
}
|
|
invalidatedAtoms.delete(_a);
|
|
}
|
|
};
|
|
var readAtomState = function readAtomState(store, atom) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var mountedMap = buildingBlocks[1];
|
|
var invalidatedAtoms = buildingBlocks[2];
|
|
var changedAtoms = buildingBlocks[3];
|
|
var storeHooks = buildingBlocks[6];
|
|
var atomRead = buildingBlocks[7];
|
|
var ensureAtomState = buildingBlocks[11];
|
|
var flushCallbacks = buildingBlocks[12];
|
|
var recomputeInvalidatedAtoms = buildingBlocks[13];
|
|
var readAtomState = buildingBlocks[14];
|
|
var writeAtomState = buildingBlocks[16];
|
|
var mountDependencies = buildingBlocks[17];
|
|
var atomState = ensureAtomState(store, atom);
|
|
if (isAtomStateInitialized(atomState)) {
|
|
if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
|
|
return atomState;
|
|
}
|
|
if (Array.from(atomState.d).every(function (_ref7) {
|
|
var a = _ref7[0],
|
|
n = _ref7[1];
|
|
return (readAtomState(store, a).n === n
|
|
);
|
|
})) {
|
|
return atomState;
|
|
}
|
|
}
|
|
atomState.d.clear();
|
|
var isSync = true;
|
|
function mountDependenciesIfAsync() {
|
|
if (mountedMap.has(atom)) {
|
|
mountDependencies(store, atom);
|
|
recomputeInvalidatedAtoms(store);
|
|
flushCallbacks(store);
|
|
}
|
|
}
|
|
function getter(a) {
|
|
if (a === atom) {
|
|
var _aState2 = ensureAtomState(store, a);
|
|
if (!isAtomStateInitialized(_aState2)) {
|
|
if (hasInitialValue(a)) {
|
|
setAtomStateValueOrPromise(store, a, a.init);
|
|
} else {
|
|
throw new Error('no atom init');
|
|
}
|
|
}
|
|
return returnAtomValue(_aState2);
|
|
}
|
|
var aState = readAtomState(store, a);
|
|
try {
|
|
return returnAtomValue(aState);
|
|
} finally {
|
|
var _mountedMap$get3;
|
|
atomState.d.set(a, aState.n);
|
|
if (isPendingPromise(atomState.v)) {
|
|
addPendingPromiseToDependency(atom, atomState.v, aState);
|
|
}
|
|
(_mountedMap$get3 = mountedMap.get(a)) == null || _mountedMap$get3.t.add(atom);
|
|
if (!isSync) {
|
|
mountDependenciesIfAsync();
|
|
}
|
|
}
|
|
}
|
|
var controller;
|
|
var setSelf;
|
|
var options = {
|
|
get signal() {
|
|
if (!controller) {
|
|
controller = new AbortController();
|
|
}
|
|
return controller.signal;
|
|
},
|
|
get setSelf() {
|
|
if (process.env.NODE_ENV !== 'production' && !isActuallyWritableAtom(atom)) {
|
|
console.warn('setSelf function cannot be used with read-only atom');
|
|
}
|
|
if (!setSelf && isActuallyWritableAtom(atom)) {
|
|
setSelf = function setSelf() {
|
|
if (process.env.NODE_ENV !== 'production' && isSync) {
|
|
console.warn('setSelf function cannot be called in sync');
|
|
}
|
|
if (!isSync) {
|
|
try {
|
|
for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
|
|
args[_key3] = arguments[_key3];
|
|
}
|
|
return writeAtomState.apply(void 0, [store, atom].concat(args));
|
|
} finally {
|
|
recomputeInvalidatedAtoms(store);
|
|
flushCallbacks(store);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
return setSelf;
|
|
}
|
|
};
|
|
var prevEpochNumber = atomState.n;
|
|
try {
|
|
var _valueOrPromise = atomRead(store, atom, getter, options);
|
|
setAtomStateValueOrPromise(store, atom, _valueOrPromise);
|
|
if (isPromiseLike(_valueOrPromise)) {
|
|
registerAbortHandler(_valueOrPromise, function () {
|
|
var _controller;
|
|
return (_controller = controller) == null ? void 0 : _controller.abort();
|
|
});
|
|
_valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
|
|
}
|
|
storeHooks.r == null || storeHooks.r(atom);
|
|
return atomState;
|
|
} catch (error) {
|
|
delete atomState.v;
|
|
atomState.e = error;
|
|
++atomState.n;
|
|
return atomState;
|
|
} finally {
|
|
isSync = false;
|
|
if (prevEpochNumber !== atomState.n && invalidatedAtoms.get(atom) === prevEpochNumber) {
|
|
invalidatedAtoms.set(atom, atomState.n);
|
|
changedAtoms.add(atom);
|
|
storeHooks.c == null || storeHooks.c(atom);
|
|
}
|
|
}
|
|
};
|
|
var invalidateDependents = function invalidateDependents(store, atom) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var mountedMap = buildingBlocks[1];
|
|
var invalidatedAtoms = buildingBlocks[2];
|
|
var ensureAtomState = buildingBlocks[11];
|
|
var stack = [atom];
|
|
while (stack.length) {
|
|
var a = stack.pop();
|
|
var aState = ensureAtomState(store, a);
|
|
for (var _iterator5 = _createForOfIteratorHelperLoose(getMountedOrPendingDependents(a, aState, mountedMap)), _step5; !(_step5 = _iterator5()).done;) {
|
|
var d = _step5.value;
|
|
var dState = ensureAtomState(store, d);
|
|
invalidatedAtoms.set(d, dState.n);
|
|
stack.push(d);
|
|
}
|
|
}
|
|
};
|
|
var _writeAtomState = function writeAtomState(store, atom) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var changedAtoms = buildingBlocks[3];
|
|
var storeHooks = buildingBlocks[6];
|
|
var atomWrite = buildingBlocks[8];
|
|
var ensureAtomState = buildingBlocks[11];
|
|
var flushCallbacks = buildingBlocks[12];
|
|
var recomputeInvalidatedAtoms = buildingBlocks[13];
|
|
var readAtomState = buildingBlocks[14];
|
|
var invalidateDependents = buildingBlocks[15];
|
|
var mountDependencies = buildingBlocks[17];
|
|
var isSync = true;
|
|
var getter = function getter(a) {
|
|
return returnAtomValue(readAtomState(store, a));
|
|
};
|
|
var setter = function setter(a) {
|
|
var aState = ensureAtomState(store, a);
|
|
try {
|
|
for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
|
|
args[_key5 - 1] = arguments[_key5];
|
|
}
|
|
if (a === atom) {
|
|
if (!hasInitialValue(a)) {
|
|
throw new Error('atom not writable');
|
|
}
|
|
var prevEpochNumber = aState.n;
|
|
var v = args[0];
|
|
setAtomStateValueOrPromise(store, a, v);
|
|
mountDependencies(store, a);
|
|
if (prevEpochNumber !== aState.n) {
|
|
changedAtoms.add(a);
|
|
storeHooks.c == null || storeHooks.c(a);
|
|
invalidateDependents(store, a);
|
|
}
|
|
return undefined;
|
|
} else {
|
|
return _writeAtomState.apply(void 0, [store, a].concat(args));
|
|
}
|
|
} finally {
|
|
if (!isSync) {
|
|
recomputeInvalidatedAtoms(store);
|
|
flushCallbacks(store);
|
|
}
|
|
}
|
|
};
|
|
try {
|
|
for (var _len4 = arguments.length, args = new Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
|
|
args[_key4 - 2] = arguments[_key4];
|
|
}
|
|
return atomWrite.apply(void 0, [store, atom, getter, setter].concat(args));
|
|
} finally {
|
|
isSync = false;
|
|
}
|
|
};
|
|
var mountDependencies = function mountDependencies(store, atom) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var mountedMap = buildingBlocks[1];
|
|
var changedAtoms = buildingBlocks[3];
|
|
var storeHooks = buildingBlocks[6];
|
|
var ensureAtomState = buildingBlocks[11];
|
|
var invalidateDependents = buildingBlocks[15];
|
|
var mountAtom = buildingBlocks[18];
|
|
var unmountAtom = buildingBlocks[19];
|
|
var atomState = ensureAtomState(store, atom);
|
|
var mounted = mountedMap.get(atom);
|
|
if (mounted && !isPendingPromise(atomState.v)) {
|
|
for (var _iterator6 = _createForOfIteratorHelperLoose(atomState.d), _step6; !(_step6 = _iterator6()).done;) {
|
|
var _step6$value = _step6.value,
|
|
a = _step6$value[0],
|
|
_n = _step6$value[1];
|
|
if (!mounted.d.has(a)) {
|
|
var aState = ensureAtomState(store, a);
|
|
var aMounted = mountAtom(store, a);
|
|
aMounted.t.add(atom);
|
|
mounted.d.add(a);
|
|
if (_n !== aState.n) {
|
|
changedAtoms.add(a);
|
|
storeHooks.c == null || storeHooks.c(a);
|
|
invalidateDependents(store, a);
|
|
}
|
|
}
|
|
}
|
|
for (var _iterator7 = _createForOfIteratorHelperLoose(mounted.d || []), _step7; !(_step7 = _iterator7()).done;) {
|
|
var _a2 = _step7.value;
|
|
if (!atomState.d.has(_a2)) {
|
|
mounted.d.delete(_a2);
|
|
var _aMounted = unmountAtom(store, _a2);
|
|
_aMounted == null || _aMounted.t.delete(atom);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var _mountAtom = function mountAtom(store, atom) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var mountedMap = buildingBlocks[1];
|
|
var mountCallbacks = buildingBlocks[4];
|
|
var storeHooks = buildingBlocks[6];
|
|
var atomOnMount = buildingBlocks[10];
|
|
var ensureAtomState = buildingBlocks[11];
|
|
var flushCallbacks = buildingBlocks[12];
|
|
var recomputeInvalidatedAtoms = buildingBlocks[13];
|
|
var readAtomState = buildingBlocks[14];
|
|
var writeAtomState = buildingBlocks[16];
|
|
var atomState = ensureAtomState(store, atom);
|
|
var mounted = mountedMap.get(atom);
|
|
if (!mounted) {
|
|
readAtomState(store, atom);
|
|
for (var _iterator8 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step8; !(_step8 = _iterator8()).done;) {
|
|
var a = _step8.value;
|
|
var aMounted = _mountAtom(store, a);
|
|
aMounted.t.add(atom);
|
|
}
|
|
mounted = {
|
|
l: new Set(),
|
|
d: new Set(atomState.d.keys()),
|
|
t: new Set()
|
|
};
|
|
mountedMap.set(atom, mounted);
|
|
storeHooks.m == null || storeHooks.m(atom);
|
|
if (isActuallyWritableAtom(atom)) {
|
|
var processOnMount = function processOnMount() {
|
|
var isSync = true;
|
|
var setAtom = function setAtom() {
|
|
try {
|
|
for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
|
|
args[_key6] = arguments[_key6];
|
|
}
|
|
return writeAtomState.apply(void 0, [store, atom].concat(args));
|
|
} finally {
|
|
if (!isSync) {
|
|
recomputeInvalidatedAtoms(store);
|
|
flushCallbacks(store);
|
|
}
|
|
}
|
|
};
|
|
try {
|
|
var onUnmount = atomOnMount(store, atom, setAtom);
|
|
if (onUnmount) {
|
|
mounted.u = function () {
|
|
isSync = true;
|
|
try {
|
|
onUnmount();
|
|
} finally {
|
|
isSync = false;
|
|
}
|
|
};
|
|
}
|
|
} finally {
|
|
isSync = false;
|
|
}
|
|
};
|
|
mountCallbacks.add(processOnMount);
|
|
}
|
|
}
|
|
return mounted;
|
|
};
|
|
var unmountAtom = function unmountAtom(store, atom) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var mountedMap = buildingBlocks[1];
|
|
var unmountCallbacks = buildingBlocks[5];
|
|
var storeHooks = buildingBlocks[6];
|
|
var ensureAtomState = buildingBlocks[11];
|
|
var unmountAtom = buildingBlocks[19];
|
|
var atomState = ensureAtomState(store, atom);
|
|
var mounted = mountedMap.get(atom);
|
|
if (mounted && !mounted.l.size && !Array.from(mounted.t).some(function (a) {
|
|
var _mountedMap$get4;
|
|
return (_mountedMap$get4 = mountedMap.get(a)) == null ? void 0 : _mountedMap$get4.d.has(atom);
|
|
})) {
|
|
if (mounted.u) {
|
|
unmountCallbacks.add(mounted.u);
|
|
}
|
|
mounted = undefined;
|
|
mountedMap.delete(atom);
|
|
storeHooks.u == null || storeHooks.u(atom);
|
|
for (var _iterator9 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step9; !(_step9 = _iterator9()).done;) {
|
|
var a = _step9.value;
|
|
var aMounted = unmountAtom(store, a);
|
|
aMounted == null || aMounted.t.delete(atom);
|
|
}
|
|
return undefined;
|
|
}
|
|
return mounted;
|
|
};
|
|
var setAtomStateValueOrPromise = function setAtomStateValueOrPromise(store, atom, valueOrPromise) {
|
|
var ensureAtomState = getInternalBuildingBlocks(store)[11];
|
|
var atomState = ensureAtomState(store, atom);
|
|
var hasPrevValue = 'v' in atomState;
|
|
var prevValue = atomState.v;
|
|
if (isPromiseLike(valueOrPromise)) {
|
|
for (var _iterator0 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step0; !(_step0 = _iterator0()).done;) {
|
|
var a = _step0.value;
|
|
addPendingPromiseToDependency(atom, valueOrPromise, ensureAtomState(store, a));
|
|
}
|
|
}
|
|
atomState.v = valueOrPromise;
|
|
delete atomState.e;
|
|
if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
|
|
++atomState.n;
|
|
if (isPromiseLike(prevValue)) {
|
|
abortPromise(prevValue);
|
|
}
|
|
}
|
|
};
|
|
var storeGet = function storeGet(store, atom) {
|
|
var readAtomState = getInternalBuildingBlocks(store)[14];
|
|
return returnAtomValue(readAtomState(store, atom));
|
|
};
|
|
var storeSet = function storeSet(store, atom) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var flushCallbacks = buildingBlocks[12];
|
|
var recomputeInvalidatedAtoms = buildingBlocks[13];
|
|
var writeAtomState = buildingBlocks[16];
|
|
try {
|
|
for (var _len7 = arguments.length, args = new Array(_len7 > 2 ? _len7 - 2 : 0), _key7 = 2; _key7 < _len7; _key7++) {
|
|
args[_key7 - 2] = arguments[_key7];
|
|
}
|
|
return writeAtomState.apply(void 0, [store, atom].concat(args));
|
|
} finally {
|
|
recomputeInvalidatedAtoms(store);
|
|
flushCallbacks(store);
|
|
}
|
|
};
|
|
var storeSub = function storeSub(store, atom, listener) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var flushCallbacks = buildingBlocks[12];
|
|
var mountAtom = buildingBlocks[18];
|
|
var unmountAtom = buildingBlocks[19];
|
|
var mounted = mountAtom(store, atom);
|
|
var listeners = mounted.l;
|
|
listeners.add(listener);
|
|
flushCallbacks(store);
|
|
return function () {
|
|
listeners.delete(listener);
|
|
unmountAtom(store, atom);
|
|
flushCallbacks(store);
|
|
};
|
|
};
|
|
var buildingBlockMap = new WeakMap();
|
|
var getInternalBuildingBlocks = function getInternalBuildingBlocks(store) {
|
|
var buildingBlocks = buildingBlockMap.get(store);
|
|
if (process.env.NODE_ENV !== 'production' && !buildingBlocks) {
|
|
throw new Error('Store must be created by buildStore to read its building blocks');
|
|
}
|
|
return buildingBlocks;
|
|
};
|
|
function getBuildingBlocks(store) {
|
|
var buildingBlocks = getInternalBuildingBlocks(store);
|
|
var enhanceBuildingBlocks = buildingBlocks[24];
|
|
if (enhanceBuildingBlocks) {
|
|
return enhanceBuildingBlocks(buildingBlocks);
|
|
}
|
|
return buildingBlocks;
|
|
}
|
|
function buildStore() {
|
|
for (var _len8 = arguments.length, buildArgs = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
|
|
buildArgs[_key8] = arguments[_key8];
|
|
}
|
|
var store = {
|
|
get: function get(atom) {
|
|
var storeGet = getInternalBuildingBlocks(store)[21];
|
|
return storeGet(store, atom);
|
|
},
|
|
set: function set(atom) {
|
|
var storeSet = getInternalBuildingBlocks(store)[22];
|
|
for (var _len9 = arguments.length, args = new Array(_len9 > 1 ? _len9 - 1 : 0), _key9 = 1; _key9 < _len9; _key9++) {
|
|
args[_key9 - 1] = arguments[_key9];
|
|
}
|
|
return storeSet.apply(void 0, [store, atom].concat(args));
|
|
},
|
|
sub: function sub(atom, listener) {
|
|
var storeSub = getInternalBuildingBlocks(store)[23];
|
|
return storeSub(store, atom, listener);
|
|
}
|
|
};
|
|
var buildingBlocks = [new WeakMap(), new WeakMap(), new WeakMap(), new Set(), new Set(), new Set(), {}, atomRead, atomWrite, atomOnInit, atomOnMount, ensureAtomState, flushCallbacks, recomputeInvalidatedAtoms, readAtomState, invalidateDependents, _writeAtomState, mountDependencies, _mountAtom, unmountAtom, setAtomStateValueOrPromise, storeGet, storeSet, storeSub, undefined].map(function (fn, i) {
|
|
return buildArgs[i] || fn;
|
|
});
|
|
buildingBlockMap.set(store, Object.freeze(buildingBlocks));
|
|
return store;
|
|
}
|
|
|
|
exports.INTERNAL_abortPromise = abortPromise;
|
|
exports.INTERNAL_addPendingPromiseToDependency = addPendingPromiseToDependency;
|
|
exports.INTERNAL_buildStoreRev2 = buildStore;
|
|
exports.INTERNAL_getBuildingBlocksRev2 = getBuildingBlocks;
|
|
exports.INTERNAL_getMountedOrPendingDependents = getMountedOrPendingDependents;
|
|
exports.INTERNAL_hasInitialValue = hasInitialValue;
|
|
exports.INTERNAL_initializeStoreHooksRev2 = initializeStoreHooks;
|
|
exports.INTERNAL_isActuallyWritableAtom = isActuallyWritableAtom;
|
|
exports.INTERNAL_isAtomStateInitialized = isAtomStateInitialized;
|
|
exports.INTERNAL_isPendingPromise = isPendingPromise;
|
|
exports.INTERNAL_isPromiseLike = isPromiseLike;
|
|
exports.INTERNAL_promiseStateMap = promiseStateMap;
|
|
exports.INTERNAL_registerAbortHandler = registerAbortHandler;
|
|
exports.INTERNAL_returnAtomValue = returnAtomValue;
|