cloud-business 0.1.124-5 → 0.1.124-7

package/cloud-business.js

@@ -45496,7 +45496,7 @@
         });
         setGlobalSelect(_objectSpread2({}, selectObj));
       } else {
-        setGlobalSelect({});
+        setGlobalSelect(_objectSpread2({}, originSelectObj));
       }
     };
 
@@ -51616,6 +51616,7 @@
       };
     }();
     var handleMatch = function handleMatch() {
+      var _batchResult$data, _batchResult$data$dat;
       if (!isMatch) {
         cloudReactV2.Message.error('请先进行匹配');
         return;
@@ -51627,7 +51628,7 @@
       }
       var addNum = props.limit - resultGoodsLength$1(ctxValue.globalSelect);
       // TODO 去重
-      var addList = batchResult.data.data.slice(0, addNum);
+      var addList = ((_batchResult$data = batchResult.data) === null || _batchResult$data === void 0 ? void 0 : (_batchResult$data$dat = _batchResult$data.data) === null || _batchResult$data$dat === void 0 ? void 0 : _batchResult$data$dat.length) ? batchResult.data.data.slice(0, addNum) : [];
       ctxValue.setAllGlobalSelect(addList, ctxValue.globalSelect, true);
       if (!isSupportAllPlatShop) {
         ctxValue.setAllGlobalSearch(addList);
@@ -54604,7 +54605,7 @@
               // const tableList = Object.values(ctxValue.globalTableList);
               // ctxValue.setSkuToggleStatus(tableList, ctxValue.globalTableList, false);
               // ctxValue.setIsExpandAll(false);
-              ctxValue.setAllGlobalSelect([], ctxValue.globalSelect, false);
+              ctxValue.setAllGlobalSelect([], [], false);
               resultGoodsLength$1([]);
               setTimeout(function () {
                 setLoading(false);
@@ -114797,7 +114798,7 @@
     var key = "atom" + ++keyCount;
     var config = {
       toString: function toString() {
-        return key;
+        return  this.debugLabel ? key + ':' + this.debugLabel : key;
       }
     };
     if (typeof read === 'function') {
@@ -114827,7 +114828,7 @@
   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$2(r)) || e  ) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray$2(r)) || e) {
       t && (r = t);
       var o = 0;
       return function () {
@@ -114858,240 +114859,237 @@
   var isActuallyWritableAtom = function isActuallyWritableAtom(atom) {
     return !!atom.write;
   };
-  var cancelPromiseMap = new WeakMap();
-  var registerCancelPromise = function registerCancelPromise(promise, cancel) {
-    cancelPromiseMap.set(promise, cancel);
-    promise.catch(function () {}).finally(function () {
-      return cancelPromiseMap.delete(promise);
-    });
-  };
-  var cancelPromise = function cancelPromise(promise, next) {
-    var cancel = cancelPromiseMap.get(promise);
-    if (cancel) {
-      cancelPromiseMap.delete(promise);
-      cancel(next);
+  var CONTINUE_PROMISE = Symbol( 'CONTINUE_PROMISE' );
+  var PENDING = 'pending';
+  var FULFILLED = 'fulfilled';
+  var REJECTED = 'rejected';
+  var isContinuablePromise = function isContinuablePromise(promise) {
+    return typeof promise === 'object' && promise !== null && CONTINUE_PROMISE in promise;
+  };
+  var continuablePromiseMap = new WeakMap();
+  var createContinuablePromise = function createContinuablePromise(promise, abort, complete) {
+    if (!continuablePromiseMap.has(promise)) {
+      var continuePromise;
+      var p = new Promise(function (resolve, reject) {
+        var curr = promise;
+        var onFulfilled = function onFulfilled(me) {
+          return function (v) {
+            if (curr === me) {
+              p.status = FULFILLED;
+              p.value = v;
+              resolve(v);
+              complete();
+            }
+          };
+        };
+        var onRejected = function onRejected(me) {
+          return function (e) {
+            if (curr === me) {
+              p.status = REJECTED;
+              p.reason = e;
+              reject(e);
+              complete();
+            }
+          };
+        };
+        promise.then(onFulfilled(promise), onRejected(promise));
+        continuePromise = function continuePromise(nextPromise, nextAbort) {
+          if (nextPromise) {
+            continuablePromiseMap.set(nextPromise, p);
+            curr = nextPromise;
+            nextPromise.then(onFulfilled(nextPromise), onRejected(nextPromise));
+            abort();
+            abort = nextAbort;
+          }
+        };
+      });
+      p.status = PENDING;
+      p[CONTINUE_PROMISE] = continuePromise;
+      continuablePromiseMap.set(promise, p);
     }
-  };
-  var resolvePromise = function resolvePromise(promise, value) {
-    promise.status = 'fulfilled';
-    promise.value = value;
-  };
-  var rejectPromise = function rejectPromise(promise, e) {
-    promise.status = 'rejected';
-    promise.reason = e;
+    return continuablePromiseMap.get(promise);
   };
   var isPromiseLike = function isPromiseLike(x) {
     return typeof (x == null ? void 0 : x.then) === 'function';
   };
-  var isEqualAtomValue = function isEqualAtomValue(a, b) {
-    return !!a && 'v' in a && 'v' in b && Object.is(a.v, b.v);
-  };
-  var isEqualAtomError = function isEqualAtomError(a, b) {
-    return !!a && 'e' in a && 'e' in b && Object.is(a.e, b.e);
-  };
-  var hasPromiseAtomValue = function hasPromiseAtomValue(a) {
-    return !!a && 'v' in a && a.v instanceof Promise;
-  };
-  var isEqualPromiseAtomValue = function isEqualPromiseAtomValue(a, b) {
-    return 'v' in a && 'v' in b && a.v.orig && a.v.orig === b.v.orig;
+  var isAtomStateInitialized = function isAtomStateInitialized(atomState) {
+    return 'v' in atomState || 'e' in atomState;
   };
   var returnAtomValue = function returnAtomValue(atomState) {
     if ('e' in atomState) {
       throw atomState.e;
     }
+    if ( !('v' in atomState)) {
+      throw new Error('[Bug] atom state is not initialized');
+    }
     return atomState.v;
   };
-  var createStore$1$1 = function createStore() {
+  var getPendingContinuablePromise = function getPendingContinuablePromise(atomState) {
+    var value = atomState.v;
+    if (isContinuablePromise(value) && value.status === PENDING) {
+      return value;
+    }
+    return null;
+  };
+  var addPendingContinuablePromiseToDependency = function addPendingContinuablePromiseToDependency(atom, promise, dependencyAtomState) {
+    if (!dependencyAtomState.p.has(atom)) {
+      dependencyAtomState.p.add(atom);
+      promise.then(function () {
+        dependencyAtomState.p.delete(atom);
+      }, function () {
+        dependencyAtomState.p.delete(atom);
+      });
+    }
+  };
+  var createPending = function createPending() {
+    return [new Map(), new Map(), new Set()];
+  };
+  var addPendingAtom = function addPendingAtom(pending, atom, atomState) {
+    if (!pending[0].has(atom)) {
+      pending[0].set(atom, new Set());
+    }
+    pending[1].set(atom, atomState);
+  };
+  var addPendingDependent = function addPendingDependent(pending, atom, dependent) {
+    var dependents = pending[0].get(atom);
+    if (dependents) {
+      dependents.add(dependent);
+    }
+  };
+  var getPendingDependents = function getPendingDependents(pending, atom) {
+    return pending[0].get(atom);
+  };
+  var addPendingFunction = function addPendingFunction(pending, fn) {
+    pending[2].add(fn);
+  };
+  var flushPending = function flushPending(pending) {
+    while (pending[1].size || pending[2].size) {
+      pending[0].clear();
+      var _atomStates = new Set(pending[1].values());
+      pending[1].clear();
+      var _functions = new Set(pending[2]);
+      pending[2].clear();
+      _atomStates.forEach(function (atomState) {
+        var _atomState$m;
+        return (_atomState$m = atomState.m) == null ? void 0 : _atomState$m.l.forEach(function (l) {
+          return l();
+        });
+      });
+      _functions.forEach(function (fn) {
+        return fn();
+      });
+    }
+  };
+  var createStore$2 = function createStore() {
     var atomStateMap = new WeakMap();
-    var mountedMap = new WeakMap();
-    var pendingStack = [];
-    var pendingMap = new WeakMap();
-    var devListenersRev2;
-    var mountedAtoms;
+    var debugMountedAtoms;
     {
-      devListenersRev2 = new Set();
-      mountedAtoms = new Set();
+      debugMountedAtoms = new Set();
     }
     var getAtomState = function getAtomState(atom) {
-      return atomStateMap.get(atom);
-    };
-    var addPendingDependent = function addPendingDependent(atom, atomState) {
-      atomState.d.forEach(function (_, a) {
-        if (!pendingMap.has(a)) {
-          var aState = getAtomState(a);
-          pendingMap.set(a, [aState, new Set()]);
-          if (aState) {
-            addPendingDependent(a, aState);
-          }
-        }
-        pendingMap.get(a)[1].add(atom);
-      });
-    };
-    var setAtomState = function setAtomState(atom, atomState) {
-      var _pendingStack;
-      {
-        Object.freeze(atomState);
-      }
-      var prevAtomState = getAtomState(atom);
-      atomStateMap.set(atom, atomState);
-      (_pendingStack = pendingStack[pendingStack.length - 1]) == null || _pendingStack.add(atom);
-      if (!pendingMap.has(atom)) {
-        pendingMap.set(atom, [prevAtomState, new Set()]);
-        addPendingDependent(atom, atomState);
-      }
-      if (hasPromiseAtomValue(prevAtomState)) {
-        var _next = 'v' in atomState ? atomState.v instanceof Promise ? atomState.v : Promise.resolve(atomState.v) : Promise.reject(atomState.e);
-        if (prevAtomState.v !== _next) {
-          cancelPromise(prevAtomState.v, _next);
-        }
-      }
-    };
-    var updateDependencies = function updateDependencies(atom, nextAtomState, nextDependencies, keepPreviousDependencies) {
-      var dependencies = new Map(keepPreviousDependencies ? nextAtomState.d : null);
-      var changed = false;
-      nextDependencies.forEach(function (aState, a) {
-        if (!aState && isSelfAtom(atom, a)) {
-          aState = nextAtomState;
-        }
-        if (aState) {
-          dependencies.set(a, aState);
-          if (nextAtomState.d.get(a) !== aState) {
-            changed = true;
-          }
-        } else {
-          console.warn('[Bug] atom state not found');
-        }
-      });
-      if (changed || nextAtomState.d.size !== dependencies.size) {
-        nextAtomState.d = dependencies;
+      var atomState = atomStateMap.get(atom);
+      if (!atomState) {
+        atomState = {
+          d: new Map(),
+          p: new Set(),
+          n: 0
+        };
+        atomStateMap.set(atom, atomState);
       }
+      return atomState;
     };
-    var setAtomValue = function setAtomValue(atom, value, nextDependencies, keepPreviousDependencies) {
-      var prevAtomState = getAtomState(atom);
-      var nextAtomState = {
-        d: (prevAtomState == null ? void 0 : prevAtomState.d) || new Map(),
-        v: value
-      };
-      if (nextDependencies) {
-        updateDependencies(atom, nextAtomState, nextDependencies, keepPreviousDependencies);
-      }
-      if (isEqualAtomValue(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {
-        return prevAtomState;
+    var setAtomStateValueOrPromise = function setAtomStateValueOrPromise(atom, atomState, valueOrPromise, abortPromise, completePromise) {
+      if (abortPromise === void 0) {
+        abortPromise = function abortPromise() {};
       }
-      if (hasPromiseAtomValue(prevAtomState) && hasPromiseAtomValue(nextAtomState) && isEqualPromiseAtomValue(prevAtomState, nextAtomState)) {
-        if (prevAtomState.d === nextAtomState.d) {
-          return prevAtomState;
-        } else {
-          nextAtomState.v = prevAtomState.v;
-        }
+      if (completePromise === void 0) {
+        completePromise = function completePromise() {};
       }
-      setAtomState(atom, nextAtomState);
-      return nextAtomState;
-    };
-    var setAtomValueOrPromise = function setAtomValueOrPromise(atom, valueOrPromise, nextDependencies, abortPromise) {
+      var hasPrevValue = 'v' in atomState;
+      var prevValue = atomState.v;
+      var pendingPromise = getPendingContinuablePromise(atomState);
       if (isPromiseLike(valueOrPromise)) {
-        var continuePromise;
-        var updatePromiseDependencies = function updatePromiseDependencies() {
-          var prevAtomState = getAtomState(atom);
-          if (!hasPromiseAtomValue(prevAtomState) || prevAtomState.v !== promise) {
-            return;
-          }
-          var nextAtomState = setAtomValue(atom, promise, nextDependencies);
-          if (mountedMap.has(atom) && prevAtomState.d !== nextAtomState.d) {
-            mountDependencies(atom, nextAtomState, prevAtomState.d);
+        if (pendingPromise) {
+          if (pendingPromise !== valueOrPromise) {
+            pendingPromise[CONTINUE_PROMISE](valueOrPromise, abortPromise);
+            ++atomState.n;
           }
-        };
-        var promise = new Promise(function (resolve, reject) {
-          var settled = false;
-          valueOrPromise.then(function (v) {
-            if (!settled) {
-              settled = true;
-              resolvePromise(promise, v);
-              resolve(v);
-              updatePromiseDependencies();
-            }
-          }, function (e) {
-            if (!settled) {
-              settled = true;
-              rejectPromise(promise, e);
-              reject(e);
-              updatePromiseDependencies();
-            }
-          });
-          continuePromise = function continuePromise(next) {
-            if (!settled) {
-              settled = true;
-              next.then(function (v) {
-                return resolvePromise(promise, v);
-              }, function (e) {
-                return rejectPromise(promise, e);
-              });
-              resolve(next);
+        } else {
+          var continuablePromise = createContinuablePromise(valueOrPromise, abortPromise, completePromise);
+          if (continuablePromise.status === PENDING) {
+            for (var _iterator = _createForOfIteratorHelperLoose(atomState.d.keys()), _step; !(_step = _iterator()).done;) {
+              var a = _step.value;
+              var aState = getAtomState(a);
+              addPendingContinuablePromiseToDependency(atom, continuablePromise, aState);
             }
-          };
-        });
-        promise.orig = valueOrPromise;
-        promise.status = 'pending';
-        registerCancelPromise(promise, function (next) {
-          if (next) {
-            continuePromise(next);
-            abortPromise == null || abortPromise();
           }
-        });
-        return setAtomValue(atom, promise, nextDependencies, true);
+          atomState.v = continuablePromise;
+          delete atomState.e;
+        }
+      } else {
+        if (pendingPromise) {
+          pendingPromise[CONTINUE_PROMISE](Promise.resolve(valueOrPromise), abortPromise);
+        }
+        atomState.v = valueOrPromise;
+        delete atomState.e;
+      }
+      if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
+        ++atomState.n;
       }
-      return setAtomValue(atom, valueOrPromise, nextDependencies);
     };
-    var setAtomError = function setAtomError(atom, error, nextDependencies) {
-      var prevAtomState = getAtomState(atom);
-      var nextAtomState = {
-        d: (prevAtomState == null ? void 0 : prevAtomState.d) || new Map(),
-        e: error
-      };
-      if (nextDependencies) {
-        updateDependencies(atom, nextAtomState, nextDependencies);
+    var addDependency = function addDependency(pending, atom, a, aState) {
+      var _aState$m;
+      if ( a === atom) {
+        throw new Error('[Bug] atom cannot depend on itself');
       }
-      if (isEqualAtomError(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {
-        return prevAtomState;
+      var atomState = getAtomState(atom);
+      atomState.d.set(a, aState.n);
+      var continuablePromise = getPendingContinuablePromise(atomState);
+      if (continuablePromise) {
+        addPendingContinuablePromiseToDependency(atom, continuablePromise, aState);
+      }
+      (_aState$m = aState.m) == null || _aState$m.t.add(atom);
+      if (pending) {
+        addPendingDependent(pending, a, atom);
       }
-      setAtomState(atom, nextAtomState);
-      return nextAtomState;
     };
-    var readAtomState = function readAtomState(atom, force) {
+    var readAtomState = function readAtomState(pending, atom, force) {
       var atomState = getAtomState(atom);
-      if (!(force != null && force(atom)) && atomState) {
-        if (mountedMap.has(atom)) {
+      if (!(force != null && force(atom)) && isAtomStateInitialized(atomState)) {
+        if (atomState.m) {
           return atomState;
         }
         if (Array.from(atomState.d).every(function (_ref) {
           var a = _ref[0],
-            s = _ref[1];
-          if (a === atom) {
-            return true;
-          }
-          var aState = readAtomState(a, force);
-          return aState === s || isEqualAtomValue(aState, s);
+            n = _ref[1];
+          return readAtomState(pending, a, force).n === n;
         })) {
           return atomState;
         }
       }
-      var nextDependencies = new Map();
+      atomState.d.clear();
       var isSync = true;
       var getter = function getter(a) {
         if (isSelfAtom(atom, a)) {
           var _aState = getAtomState(a);
-          if (_aState) {
-            nextDependencies.set(a, _aState);
-            return returnAtomValue(_aState);
-          }
-          if (hasInitialValue(a)) {
-            nextDependencies.set(a, undefined);
-            return a.init;
+          if (!isAtomStateInitialized(_aState)) {
+            if (hasInitialValue(a)) {
+              setAtomStateValueOrPromise(a, _aState, a.init);
+            } else {
+              throw new Error('no atom init');
+            }
           }
-          throw new Error('no atom init');
+          return returnAtomValue(_aState);
+        }
+        var aState = readAtomState(pending, a, force);
+        if (isSync) {
+          addDependency(pending, atom, a, aState);
+        } else {
+          var _pending = createPending();
+          addDependency(_pending, atom, a, aState);
+          mountDependencies(_pending, atom, atomState);
+          flushPending(_pending);
         }
-        var aState = readAtomState(a, force);
-        nextDependencies.set(a, aState);
         return returnAtomValue(aState);
       };
       var controller;
@@ -115125,37 +115123,52 @@
       };
       try {
         var valueOrPromise = atom.read(getter, options);
-        return setAtomValueOrPromise(atom, valueOrPromise, nextDependencies, function () {
+        setAtomStateValueOrPromise(atom, atomState, valueOrPromise, function () {
           var _controller;
           return (_controller = controller) == null ? void 0 : _controller.abort();
+        }, function () {
+          if (atomState.m) {
+            var _pending2 = createPending();
+            mountDependencies(_pending2, atom, atomState);
+            flushPending(_pending2);
+          }
         });
+        return atomState;
       } catch (error) {
-        return setAtomError(atom, error, nextDependencies);
+        delete atomState.v;
+        atomState.e = error;
+        ++atomState.n;
+        return atomState;
       } finally {
         isSync = false;
       }
     };
     var readAtom = function readAtom(atom) {
-      return returnAtomValue(readAtomState(atom));
+      return returnAtomValue(readAtomState(undefined, atom));
     };
-    var recomputeDependents = function recomputeDependents(atom) {
+    var recomputeDependents = function recomputeDependents(pending, atom) {
       var getDependents = function getDependents(a) {
-        var _mountedMap$get, _pendingMap$get;
-        var dependents = new Set((_mountedMap$get = mountedMap.get(a)) == null ? void 0 : _mountedMap$get.t);
-        (_pendingMap$get = pendingMap.get(a)) == null || _pendingMap$get[1].forEach(function (dependent) {
+        var _aState$m2, _getPendingDependents;
+        var aState = getAtomState(a);
+        var dependents = new Set((_aState$m2 = aState.m) == null ? void 0 : _aState$m2.t);
+        for (var _iterator2 = _createForOfIteratorHelperLoose(aState.p), _step2; !(_step2 = _iterator2()).done;) {
+          var atomWithPendingContinuablePromise = _step2.value;
+          dependents.add(atomWithPendingContinuablePromise);
+        }
+        (_getPendingDependents = getPendingDependents(pending, a)) == null || _getPendingDependents.forEach(function (dependent) {
           dependents.add(dependent);
         });
         return dependents;
       };
-      var topsortedAtoms = new Array();
+      var topsortedAtoms = [];
       var markedAtoms = new Set();
       var visit = function visit(n) {
         if (markedAtoms.has(n)) {
           return;
         }
         markedAtoms.add(n);
-        for (var _iterator = _createForOfIteratorHelperLoose(getDependents(n)), _step; !(_step = _iterator()).done;) {
-          var m = _step.value;
+        for (var _iterator3 = _createForOfIteratorHelperLoose(getDependents(n)), _step3; !(_step3 = _iterator3()).done;) {
+          var m = _step3.value;
           if (n !== m) {
             visit(m);
           }
@@ -115169,37 +115182,32 @@
       };
       for (var i = topsortedAtoms.length - 1; i >= 0; --i) {
         var a = topsortedAtoms[i];
-        var _prevAtomState = getAtomState(a);
-        if (!_prevAtomState) {
-          continue;
-        }
+        var aState = getAtomState(a);
+        var prevEpochNumber = aState.n;
         var hasChangedDeps = false;
-        for (var _iterator2 = _createForOfIteratorHelperLoose(_prevAtomState.d.keys()), _step2; !(_step2 = _iterator2()).done;) {
-          var dep = _step2.value;
+        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) {
-          var nextAtomState = readAtomState(a, isMarked);
-          addPendingDependent(a, nextAtomState);
-          if (!isEqualAtomValue(_prevAtomState, nextAtomState)) {
+          readAtomState(pending, a, isMarked);
+          mountDependencies(pending, a, aState);
+          if (prevEpochNumber !== aState.n) {
+            addPendingAtom(pending, a, aState);
             changedAtoms.add(a);
           }
         }
         markedAtoms.delete(a);
       }
     };
-    var writeAtomState = function writeAtomState(atom) {
+    var writeAtomState = function writeAtomState(pending, atom) {
       var getter = function getter(a) {
-        return returnAtomValue(readAtomState(a));
+        return returnAtomValue(readAtomState(pending, a));
       };
       var setter = function setter(a) {
-        var isSync = pendingStack.length > 0;
-        if (!isSync) {
-          pendingStack.push(new Set([a]));
-        }
         var r;
         for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
           args[_key3 - 1] = arguments[_key3];
@@ -115208,277 +115216,177 @@
           if (!hasInitialValue(a)) {
             throw new Error('atom not writable');
           }
-          var _prevAtomState2 = getAtomState(a);
-          var nextAtomState = setAtomValueOrPromise(a, args[0]);
-          if (!isEqualAtomValue(_prevAtomState2, nextAtomState)) {
-            recomputeDependents(a);
+          var aState = getAtomState(a);
+          var hasPrevValue = 'v' in aState;
+          var prevValue = aState.v;
+          var v = args[0];
+          setAtomStateValueOrPromise(a, aState, v);
+          mountDependencies(pending, a, aState);
+          if (!hasPrevValue || !Object.is(prevValue, aState.v)) {
+            addPendingAtom(pending, a, aState);
+            recomputeDependents(pending, a);
           }
         } else {
-          r = writeAtomState.apply(void 0, [a].concat(args));
-        }
-        if (!isSync) {
-          var flushed = flushPending(pendingStack.pop());
-          {
-            devListenersRev2.forEach(function (l) {
-              return l({
-                type: 'async-write',
-                flushed: flushed
-              });
-            });
-          }
+          r = writeAtomState.apply(void 0, [pending, a].concat(args));
         }
+        flushPending(pending);
         return r;
       };
-      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-        args[_key2 - 1] = arguments[_key2];
+      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        args[_key2 - 2] = arguments[_key2];
       }
       var result = atom.write.apply(atom, [getter, setter].concat(args));
       return result;
     };
     var writeAtom = function writeAtom(atom) {
-      pendingStack.push(new Set([atom]));
+      var pending = createPending();
       for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
         args[_key4 - 1] = arguments[_key4];
       }
-      var result = writeAtomState.apply(void 0, [atom].concat(args));
-      var flushed = flushPending(pendingStack.pop());
-      {
-        devListenersRev2.forEach(function (l) {
-          return l({
-            type: 'write',
-            flushed: flushed
-          });
-        });
-      }
+      var result = writeAtomState.apply(void 0, [pending, atom].concat(args));
+      flushPending(pending);
       return result;
     };
-    var mountAtom = function mountAtom(atom, initialDependent, onMountQueue) {
-      var _getAtomState;
-      var existingMount = mountedMap.get(atom);
-      if (existingMount) {
-        if (initialDependent) {
-          existingMount.t.add(initialDependent);
-        }
-        return existingMount;
-      }
-      var queue = onMountQueue || [];
-      (_getAtomState = getAtomState(atom)) == null || _getAtomState.d.forEach(function (_, a) {
-        if (a !== atom) {
-          mountAtom(a, atom, queue);
+    var mountDependencies = function mountDependencies(pending, atom, atomState) {
+      if (atomState.m && !getPendingContinuablePromise(atomState)) {
+        for (var _iterator5 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step5; !(_step5 = _iterator5()).done;) {
+          var a = _step5.value;
+          if (!atomState.m.d.has(a)) {
+            var aMounted = mountAtom(pending, a);
+            aMounted.t.add(atom);
+            atomState.m.d.add(a);
+          }
         }
-      });
-      readAtomState(atom);
-      var mounted = {
-        t: new Set(initialDependent && [initialDependent]),
-        l: new Set()
-      };
-      mountedMap.set(atom, mounted);
-      {
-        mountedAtoms.add(atom);
-      }
-      if (isActuallyWritableAtom(atom) && atom.onMount) {
-        var onMount = atom.onMount;
-        queue.push(function () {
-          var onUnmount = onMount(function () {
-            for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
-              args[_key5] = arguments[_key5];
-            }
-            return writeAtom.apply(void 0, [atom].concat(args));
-          });
-          if (onUnmount) {
-            mounted.u = onUnmount;
+        for (var _iterator6 = _createForOfIteratorHelperLoose(atomState.m.d || []), _step6; !(_step6 = _iterator6()).done;) {
+          var _a = _step6.value;
+          if (!atomState.d.has(_a)) {
+            atomState.m.d.delete(_a);
+            var _aMounted = unmountAtom(pending, _a);
+            _aMounted == null || _aMounted.t.delete(atom);
           }
-        });
-      }
-      if (!onMountQueue) {
-        queue.forEach(function (f) {
-          return f();
-        });
+        }
       }
-      return mounted;
-    };
-    var canUnmountAtom = function canUnmountAtom(atom, mounted) {
-      return !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom));
     };
-    var tryUnmountAtom = function tryUnmountAtom(atom, mounted) {
-      if (!canUnmountAtom(atom, mounted)) {
-        return;
-      }
-      var onUnmount = mounted.u;
-      if (onUnmount) {
-        onUnmount();
-      }
-      mountedMap.delete(atom);
-      {
-        mountedAtoms.delete(atom);
-      }
+    var mountAtom = function mountAtom(pending, atom) {
       var atomState = getAtomState(atom);
-      if (atomState) {
-        if (hasPromiseAtomValue(atomState)) {
-          cancelPromise(atomState.v);
-        }
-        atomState.d.forEach(function (_, a) {
-          if (a !== atom) {
-            var mountedDep = mountedMap.get(a);
-            if (mountedDep) {
-              mountedDep.t.delete(atom);
-              tryUnmountAtom(a, mountedDep);
+      if (!atomState.m) {
+        readAtomState(pending, atom);
+        for (var _iterator7 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step7; !(_step7 = _iterator7()).done;) {
+          var a = _step7.value;
+          var aMounted = mountAtom(pending, a);
+          aMounted.t.add(atom);
+        }
+        atomState.m = {
+          l: new Set(),
+          d: new Set(atomState.d.keys()),
+          t: new Set()
+        };
+        {
+          debugMountedAtoms.add(atom);
+        }
+        if (isActuallyWritableAtom(atom) && atom.onMount) {
+          var mounted = atomState.m;
+          var onMount = atom.onMount;
+          addPendingFunction(pending, function () {
+            var onUnmount = onMount(function () {
+              for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+                args[_key5] = arguments[_key5];
+              }
+              return writeAtomState.apply(void 0, [pending, atom].concat(args));
+            });
+            if (onUnmount) {
+              mounted.u = onUnmount;
             }
-          }
-        });
-      } else {
-        console.warn('[Bug] could not find atom state to unmount', atom);
+          });
+        }
       }
+      return atomState.m;
     };
-    var mountDependencies = function mountDependencies(atom, atomState, prevDependencies) {
-      var depSet = new Set(atomState.d.keys());
-      var maybeUnmountAtomSet = new Set();
-      prevDependencies == null || prevDependencies.forEach(function (_, a) {
-        if (depSet.has(a)) {
-          depSet.delete(a);
-          return;
-        }
-        maybeUnmountAtomSet.add(a);
-        var mounted = mountedMap.get(a);
-        if (mounted) {
-          mounted.t.delete(atom);
-        }
-      });
-      depSet.forEach(function (a) {
-        mountAtom(a, atom);
-      });
-      maybeUnmountAtomSet.forEach(function (a) {
-        var mounted = mountedMap.get(a);
-        if (mounted) {
-          tryUnmountAtom(a, mounted);
+    var unmountAtom = function unmountAtom(pending, atom) {
+      var atomState = getAtomState(atom);
+      if (atomState.m && !atomState.m.l.size && !Array.from(atomState.m.t).some(function (a) {
+        var _getAtomState$m;
+        return (_getAtomState$m = getAtomState(a).m) == null ? void 0 : _getAtomState$m.d.has(atom);
+      })) {
+        var onUnmount = atomState.m.u;
+        if (onUnmount) {
+          addPendingFunction(pending, onUnmount);
         }
-      });
-    };
-    var flushPending = function flushPending(pendingAtoms) {
-      var flushed;
-      {
-        flushed = new Set();
-      }
-      var pending = [];
-      var collectPending = function collectPending(pendingAtom) {
-        var _getAtomState2;
-        if (!pendingMap.has(pendingAtom)) {
-          return;
+        delete atomState.m;
+        {
+          debugMountedAtoms.delete(atom);
         }
-        var _ref2 = pendingMap.get(pendingAtom),
-          prevAtomState = _ref2[0],
-          dependents = _ref2[1];
-        pendingMap.delete(pendingAtom);
-        pending.push([pendingAtom, prevAtomState]);
-        dependents.forEach(collectPending);
-        (_getAtomState2 = getAtomState(pendingAtom)) == null || _getAtomState2.d.forEach(function (_, a) {
-          return collectPending(a);
-        });
-      };
-      pendingAtoms.forEach(collectPending);
-      pending.forEach(function (_ref3) {
-        var atom = _ref3[0],
-          prevAtomState = _ref3[1];
-        var atomState = getAtomState(atom);
-        if (!atomState) {
-          {
-            console.warn('[Bug] no atom state to flush');
-          }
-          return;
+        for (var _iterator8 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step8; !(_step8 = _iterator8()).done;) {
+          var a = _step8.value;
+          var aMounted = unmountAtom(pending, a);
+          aMounted == null || aMounted.t.delete(atom);
         }
-        if (atomState !== prevAtomState) {
-          var mounted = mountedMap.get(atom);
-          if (mounted && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {
-            mountDependencies(atom, atomState, prevAtomState == null ? void 0 : prevAtomState.d);
-          }
-          if (mounted && !(!hasPromiseAtomValue(prevAtomState) && (isEqualAtomValue(prevAtomState, atomState) || isEqualAtomError(prevAtomState, atomState)))) {
-            mounted.l.forEach(function (listener) {
-              return listener();
-            });
-            {
-              flushed.add(atom);
-            }
-          }
+        var pendingPromise = getPendingContinuablePromise(atomState);
+        if (pendingPromise) {
+          pendingPromise[CONTINUE_PROMISE](undefined, function () {});
         }
-      });
-      {
-        return flushed;
+        return undefined;
       }
+      return atomState.m;
     };
     var subscribeAtom = function subscribeAtom(atom, listener) {
-      var mounted = mountAtom(atom);
-      var flushed = flushPending([atom]);
+      var pending = createPending();
+      var mounted = mountAtom(pending, atom);
+      flushPending(pending);
       var listeners = mounted.l;
       listeners.add(listener);
-      {
-        devListenersRev2.forEach(function (l) {
-          return l({
-            type: 'sub',
-            flushed: flushed
-          });
-        });
-      }
       return function () {
         listeners.delete(listener);
-        tryUnmountAtom(atom, mounted);
-        {
-          devListenersRev2.forEach(function (l) {
-            return l({
-              type: 'unsub'
-            });
-          });
-        }
+        var pending = createPending();
+        unmountAtom(pending, atom);
+        flushPending(pending);
       };
     };
+    var store = {
+      get: readAtom,
+      set: writeAtom,
+      sub: subscribeAtom
+    };
     {
-      return {
-        get: readAtom,
-        set: writeAtom,
-        sub: subscribeAtom,
-        dev_subscribe_store: function dev_subscribe_store(l) {
-          devListenersRev2.add(l);
-          return function () {
-            devListenersRev2.delete(l);
-          };
-        },
-        dev_get_mounted_atoms: function dev_get_mounted_atoms() {
-          return mountedAtoms.values();
-        },
-        dev_get_atom_state: function dev_get_atom_state(a) {
-          return atomStateMap.get(a);
+      var devStore = {
+        dev4_get_internal_weak_map: function dev4_get_internal_weak_map() {
+          return atomStateMap;
         },
-        dev_get_mounted: function dev_get_mounted(a) {
-          return mountedMap.get(a);
+        dev4_get_mounted_atoms: function dev4_get_mounted_atoms() {
+          return debugMountedAtoms;
         },
-        dev_restore_atoms: function dev_restore_atoms(values) {
-          pendingStack.push(new Set());
-          for (var _iterator3 = _createForOfIteratorHelperLoose(values), _step3; !(_step3 = _iterator3()).done;) {
-            var _step3$value = _step3.value,
-              atom = _step3$value[0],
-              valueOrPromise = _step3$value[1];
+        dev4_restore_atoms: function dev4_restore_atoms(values) {
+          var pending = createPending();
+          for (var _iterator9 = _createForOfIteratorHelperLoose(values), _step9; !(_step9 = _iterator9()).done;) {
+            var _step9$value = _step9.value,
+              atom = _step9$value[0],
+              value = _step9$value[1];
             if (hasInitialValue(atom)) {
-              setAtomValueOrPromise(atom, valueOrPromise);
-              recomputeDependents(atom);
+              var atomState = getAtomState(atom);
+              var hasPrevValue = 'v' in atomState;
+              var prevValue = atomState.v;
+              setAtomStateValueOrPromise(atom, atomState, value);
+              mountDependencies(pending, atom, atomState);
+              if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
+                addPendingAtom(pending, atom, atomState);
+                recomputeDependents(pending, atom);
+              }
             }
           }
-          var flushed = flushPending(pendingStack.pop());
-          devListenersRev2.forEach(function (l) {
-            return l({
-              type: 'restore',
-              flushed: flushed
-            });
-          });
+          flushPending(pending);
         }
       };
+      Object.assign(store, devStore);
     }
+    return store;
   };
   var defaultStore;
-  var getDefaultStore$1 = function getDefaultStore() {
+  var getDefaultStore = function getDefaultStore() {
     if (!defaultStore) {
-      defaultStore = createStore$1$1();
+      defaultStore = createStore$2();
       {
-        var _ref4;
-        (_ref4 = globalThis).__JOTAI_DEFAULT_STORE__ || (_ref4.__JOTAI_DEFAULT_STORE__ = defaultStore);
+        var _ref2;
+        (_ref2 = globalThis).__JOTAI_DEFAULT_STORE__ || (_ref2.__JOTAI_DEFAULT_STORE__ = defaultStore);
         if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
           console.warn('Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044');
         }
@@ -115487,9 +115395,6 @@
     return defaultStore;
   };
 
-  var createStore$2 = createStore$1$1;
-  var getDefaultStore = getDefaultStore$1;
-
   var atom_1 = atom;
   var createStore_1 = createStore$2;
   var getDefaultStore_1 = getDefaultStore;
@@ -115653,7 +115558,7 @@
   function _createForOfIteratorHelperLoose$1(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$3(r)) || e  ) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray$3(r)) || e) {
       t && (r = t);
       var o = 0;
       return function () {
@@ -116543,7 +116448,7 @@
   function _createForOfIteratorHelperLoose$2(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$4(r)) || e  ) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray$4(r)) || e) {
       t && (r = t);
       var o = 0;
       return function () {
@@ -146435,7 +146340,7 @@
   }
   // 检验当前运行环境
   if (typeof window === 'undefined') {
-    console.warn('cloud-business@0.1.124-5 仅支持在浏览器环境进行使用!');
+    console.warn('cloud-business@0.1.124-7 仅支持在浏览器环境进行使用!');
   }
   var bodys = document.getElementsByTagName('body')[0];
   var colors = [1, 2, 3, 4, 5, 6, 7];
@@ -146445,7 +146350,7 @@
       bodys.style.setProperty("--shuyunBlue".concat(i$2 + 1), color);
     }
   }
-  var version = '0.1.124-5';
+  var version = '0.1.124-7';
 
   exports.AreaSelector = AreaSelector;
   exports.AreaSelectorNew = AreaSelector$1;