add hw2
This commit is contained in:
nik
725
node_modules/jotai/vanilla/internals.js
generated
vendored
Normal file
725
node_modules/jotai/vanilla/internals.js
generated
vendored
Normal file
@@ -0,0 +1,725 @@
|
||||
'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;
|
||||
Reference in New Issue
Block a user