cloud-business 0.1.114-5 → 0.1.114-6

package/cloud-business.js

@@ -178175,27 +178175,45 @@
     }
     return atomState.v;
   };
-  var createStore$2 = function createStore() {
+  var createStore$1$1 = function createStore() {
     var atomStateMap = new WeakMap();
     var mountedMap = new WeakMap();
-    var pendingMap = new Map();
-    var storeListenersRev2;
+    var pendingStack = [];
+    var pendingMap = new WeakMap();
+    var devListenersRev2;
     var mountedAtoms;
     {
-      storeListenersRev2 = new Set();
+      devListenersRev2 = new Set();
       mountedAtoms = 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 _pendingStack;
+          var aState = getAtomState(a);
+          (_pendingStack = pendingStack[pendingStack.length - 1]) == null || _pendingStack.add(a);
+          pendingMap.set(a, [aState, new Set()]);
+          if (aState) {
+            addPendingDependent(a, aState);
+          }
+        }
+        pendingMap.get(a)[1].add(atom);
+      });
+    };
     var setAtomState = function setAtomState(atom, atomState) {
       {
         Object.freeze(atomState);
       }
-      var prevAtomState = atomStateMap.get(atom);
+      var prevAtomState = getAtomState(atom);
       atomStateMap.set(atom, atomState);
       if (!pendingMap.has(atom)) {
-        pendingMap.set(atom, prevAtomState);
+        var _pendingStack2;
+        (_pendingStack2 = pendingStack[pendingStack.length - 1]) == null || _pendingStack2.add(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);
@@ -178324,7 +178342,7 @@
         if (Array.from(atomState.d).every(function (_ref) {
           var a = _ref[0],
             s = _ref[1];
-          if (isSelfAtom(atom, a)) {
+          if (a === atom) {
             return true;
           }
           var aState = readAtomState(a);
@@ -178396,79 +178414,63 @@
     var readAtom = function readAtom(atom) {
       return returnAtomValue(readAtomState(atom));
     };
-    var addAtom = function addAtom(atom) {
-      var mounted = mountedMap.get(atom);
-      if (!mounted) {
-        mounted = mountAtom(atom);
-      }
-      return mounted;
-    };
-    var canUnmountAtom = function canUnmountAtom(atom, mounted) {
-      return !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom));
-    };
-    var delAtom = function delAtom(atom) {
-      var mounted = mountedMap.get(atom);
-      if (mounted && canUnmountAtom(atom, mounted)) {
-        unmountAtom(atom);
-      }
-    };
     var recomputeDependents = function recomputeDependents(atom) {
-      var dependencyMap = new Map();
-      var dirtyMap = new WeakMap();
       var getDependents = function getDependents(a) {
-        var _mountedMap$get;
+        var _mountedMap$get, _pendingMap$get;
         var dependents = new Set((_mountedMap$get = mountedMap.get(a)) == null ? void 0 : _mountedMap$get.t);
-        pendingMap.forEach(function (_, pendingAtom) {
-          var _getAtomState;
-          if ((_getAtomState = getAtomState(pendingAtom)) != null && _getAtomState.d.has(a)) {
-            dependents.add(pendingAtom);
-          }
+        (_pendingMap$get = pendingMap.get(a)) == null || _pendingMap$get[1].forEach(function (dependent) {
+          dependents.add(dependent);
         });
         return dependents;
       };
-      var loop1 = function loop1(a) {
-        getDependents(a).forEach(function (dependent) {
-          if (dependent !== a) {
-            dependencyMap.set(dependent, (dependencyMap.get(dependent) || new Set()).add(a));
-            dirtyMap.set(dependent, (dirtyMap.get(dependent) || 0) + 1);
-            loop1(dependent);
-          }
-        });
-      };
-      loop1(atom);
-      var loop2 = function loop2(a) {
-        getDependents(a).forEach(function (dependent) {
-          if (dependent !== a) {
-            var dirtyCount = dirtyMap.get(dependent);
-            if (dirtyCount) {
-              dirtyMap.set(dependent, --dirtyCount);
-            }
-            if (!dirtyCount) {
-              var _dependencyMap$get;
-              var isChanged = !!((_dependencyMap$get = dependencyMap.get(dependent)) != null && _dependencyMap$get.size);
-              if (isChanged) {
-                var prevAtomState = getAtomState(dependent);
-                var nextAtomState = readAtomState(dependent, true);
-                isChanged = !isEqualAtomValue(prevAtomState, nextAtomState);
-              }
-              if (!isChanged) {
-                dependencyMap.forEach(function (s) {
-                  return s.delete(dependent);
-                });
-              }
-            }
-            loop2(dependent);
+      var topsortedAtoms = new Array();
+      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;
+          if (n !== m) {
+            visit(m);
           }
-        });
+        }
+        topsortedAtoms.push(n);
       };
-      loop2(atom);
+      visit(atom);
+      var changedAtoms = new Set([atom]);
+      for (var i = topsortedAtoms.length - 1; i >= 0; --i) {
+        var _a = topsortedAtoms[i];
+        var _prevAtomState = getAtomState(_a);
+        if (!_prevAtomState) {
+          continue;
+        }
+        var hasChangedDeps = false;
+        for (var _iterator2 = _createForOfIteratorHelperLoose(_prevAtomState.d.keys()), _step2; !(_step2 = _iterator2()).done;) {
+          var dep = _step2.value;
+          if (dep !== _a && changedAtoms.has(dep)) {
+            hasChangedDeps = true;
+            break;
+          }
+        }
+        if (hasChangedDeps) {
+          var nextAtomState = readAtomState(_a, true);
+          if (!isEqualAtomValue(_prevAtomState, nextAtomState)) {
+            changedAtoms.add(_a);
+          }
+        }
+      }
     };
     var writeAtomState = function writeAtomState(atom) {
-      var isSync = true;
       var getter = function getter(a) {
         return returnAtomValue(readAtomState(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];
@@ -178477,18 +178479,18 @@
           if (!hasInitialValue(a)) {
             throw new Error('atom not writable');
           }
-          var prevAtomState = getAtomState(a);
+          var _prevAtomState2 = getAtomState(a);
           var nextAtomState = setAtomValueOrPromise(a, args[0]);
-          if (!isEqualAtomValue(prevAtomState, nextAtomState)) {
+          if (!isEqualAtomValue(_prevAtomState2, nextAtomState)) {
             recomputeDependents(a);
           }
         } else {
           r = writeAtomState.apply(void 0, [a].concat(args));
         }
         if (!isSync) {
-          var flushed = flushPending();
+          var flushed = flushPending(pendingStack.pop());
           {
-            storeListenersRev2.forEach(function (l) {
+            devListenersRev2.forEach(function (l) {
               return l({
                 type: 'async-write',
                 flushed: flushed
@@ -178502,17 +178504,17 @@
         args[_key2 - 1] = arguments[_key2];
       }
       var result = atom.write.apply(atom, [getter, setter].concat(args));
-      isSync = false;
       return result;
     };
     var writeAtom = function writeAtom(atom) {
+      pendingStack.push(new Set([atom]));
       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();
+      var flushed = flushPending(pendingStack.pop());
       {
-        storeListenersRev2.forEach(function (l) {
+        devListenersRev2.forEach(function (l) {
           return l({
             type: 'write',
             flushed: flushed
@@ -178522,16 +178524,18 @@
       return result;
     };
     var mountAtom = function mountAtom(atom, initialDependent, onMountQueue) {
-      var _getAtomState2;
+      var _getAtomState;
+      var existingMount = mountedMap.get(atom);
+      if (existingMount) {
+        if (initialDependent) {
+          existingMount.t.add(initialDependent);
+        }
+        return existingMount;
+      }
       var queue = onMountQueue || [];
-      (_getAtomState2 = getAtomState(atom)) == null || _getAtomState2.d.forEach(function (_, a) {
-        var aMounted = mountedMap.get(a);
-        if (aMounted) {
-          aMounted.t.add(atom);
-        } else {
-          if (a !== atom) {
-            mountAtom(a, atom, queue);
-          }
+      (_getAtomState = getAtomState(atom)) == null || _getAtomState.d.forEach(function (_, a) {
+        if (a !== atom) {
+          mountAtom(a, atom, queue);
         }
       });
       readAtomState(atom);
@@ -178564,9 +178568,14 @@
       }
       return mounted;
     };
-    var unmountAtom = function unmountAtom(atom) {
-      var _mountedMap$get2;
-      var onUnmount = (_mountedMap$get2 = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get2.u;
+    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();
       }
@@ -178581,12 +178590,10 @@
         }
         atomState.d.forEach(function (_, a) {
           if (a !== atom) {
-            var mounted = mountedMap.get(a);
-            if (mounted) {
-              mounted.t.delete(atom);
-              if (canUnmountAtom(a, mounted)) {
-                unmountAtom(a);
-              }
+            var mountedDep = mountedMap.get(a);
+            if (mountedDep) {
+              mountedDep.t.delete(atom);
+              tryUnmountAtom(a, mountedDep);
             }
           }
         });
@@ -178609,61 +178616,73 @@
         }
       });
       depSet.forEach(function (a) {
-        var mounted = mountedMap.get(a);
-        if (mounted) {
-          mounted.t.add(atom);
-        } else if (mountedMap.has(atom)) {
-          mountAtom(a, atom);
-        }
+        mountAtom(a, atom);
       });
       maybeUnmountAtomSet.forEach(function (a) {
         var mounted = mountedMap.get(a);
-        if (mounted && canUnmountAtom(a, mounted)) {
-          unmountAtom(a);
+        if (mounted) {
+          tryUnmountAtom(a, mounted);
         }
       });
     };
-    var flushPending = function flushPending() {
+    var flushPending = function flushPending(pendingAtoms) {
       var flushed;
       {
         flushed = new Set();
       }
-      while (pendingMap.size) {
-        var pending = Array.from(pendingMap);
-        pendingMap.clear();
-        pending.forEach(function (_ref2) {
-          var atom = _ref2[0],
-            prevAtomState = _ref2[1];
-          var atomState = getAtomState(atom);
-          if (atomState) {
-            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);
-              }
-            }
-          } else {
+      var pending = [];
+      var collectPending = function collectPending(pendingAtom) {
+        var _getAtomState2;
+        if (!pendingMap.has(pendingAtom)) {
+          return;
+        }
+        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;
+        }
+        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);
+            }
+          }
+        }
+      });
       {
         return flushed;
       }
     };
     var subscribeAtom = function subscribeAtom(atom, listener) {
-      var mounted = addAtom(atom);
-      var flushed = flushPending();
+      var mounted = mountAtom(atom);
+      var flushed = flushPending([atom]);
       var listeners = mounted.l;
       listeners.add(listener);
       {
-        storeListenersRev2.forEach(function (l) {
+        devListenersRev2.forEach(function (l) {
           return l({
             type: 'sub',
             flushed: flushed
@@ -178672,9 +178691,9 @@
       }
       return function () {
         listeners.delete(listener);
-        delAtom(atom);
+        tryUnmountAtom(atom, mounted);
         {
-          storeListenersRev2.forEach(function (l) {
+          devListenersRev2.forEach(function (l) {
             return l({
               type: 'unsub'
             });
@@ -178687,13 +178706,10 @@
         get: readAtom,
         set: writeAtom,
         sub: subscribeAtom,
-        dev_subscribe_store: function dev_subscribe_store(l, rev) {
-          if (rev !== 2) {
-            throw new Error('The current StoreListener revision is 2.');
-          }
-          storeListenersRev2.add(l);
+        dev_subscribe_store: function dev_subscribe_store(l) {
+          devListenersRev2.add(l);
           return function () {
-            storeListenersRev2.delete(l);
+            devListenersRev2.delete(l);
           };
         },
         dev_get_mounted_atoms: function dev_get_mounted_atoms() {
@@ -178706,17 +178722,18 @@
           return mountedMap.get(a);
         },
         dev_restore_atoms: function dev_restore_atoms(values) {
-          for (var _iterator = _createForOfIteratorHelperLoose(values), _step; !(_step = _iterator()).done;) {
-            var _step$value = _step.value,
-              atom = _step$value[0],
-              valueOrPromise = _step$value[1];
-            if (hasInitialValue(atom)) {
-              setAtomValueOrPromise(atom, valueOrPromise);
-              recomputeDependents(atom);
-            }
-          }
-          var flushed = flushPending();
-          storeListenersRev2.forEach(function (l) {
+          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];
+            if (hasInitialValue(_atom)) {
+              setAtomValueOrPromise(_atom, valueOrPromise);
+              recomputeDependents(_atom);
+            }
+          }
+          var flushed = flushPending(pendingStack.pop());
+          devListenersRev2.forEach(function (l) {
             return l({
               type: 'restore',
               flushed: flushed
@@ -178727,23 +178744,23 @@
     }
   };
   var defaultStore;
-  {
-    if (typeof globalThis.__NUMBER_OF_JOTAI_INSTANCES__ === 'number') {
-      ++globalThis.__NUMBER_OF_JOTAI_INSTANCES__;
-    } else {
-      globalThis.__NUMBER_OF_JOTAI_INSTANCES__ = 1;
-    }
-  }
-  var getDefaultStore = function getDefaultStore() {
+  var getDefaultStore$1 = function getDefaultStore() {
     if (!defaultStore) {
-      if ( globalThis.__NUMBER_OF_JOTAI_INSTANCES__ !== 1) {
-        console.warn('Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044');
+      defaultStore = createStore$1$1();
+      {
+        var _ref4;
+        (_ref4 = globalThis).__JOTAI_DEFAULT_STORE__ || (_ref4.__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');
+        }
       }
-      defaultStore = createStore$2();
     }
     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;
@@ -179006,11 +179023,11 @@
   var getCached$2 = function getCached(c, m, k) {
     return (m.has(k) ? m : m.set(k, c())).get(k);
   };
-  var cache1$4 = new WeakMap();
+  var cache1$3 = new WeakMap();
   var memo3 = function memo3(create, dep1, dep2, dep3) {
     var cache2 = getCached$2(function () {
       return new WeakMap();
-    }, cache1$4, dep1);
+    }, cache1$3, dep1);
     var cache3 = getCached$2(function () {
       return new WeakMap();
     }, cache2, dep2);
@@ -179034,9 +179051,6 @@
       var derivedAtom = vanilla.atom(function (get) {
         var prev = get(derivedAtom);
         var value = get(anAtom);
-        if (value instanceof Promise || prev instanceof Promise) {
-          return Promise.all([value, prev]).then(selectValue);
-        }
         return selectValue([value, prev]);
       });
       derivedAtom.init = EMPTY;
@@ -179044,10 +179058,7 @@
     }, anAtom, selector, equalityFn);
   }
 
-  var cache1$3 = new WeakMap();
-  var memo1$1 = function memo1(create, dep1) {
-    return (cache1$3.has(dep1) ? cache1$3 : cache1$3.set(dep1, create())).get(dep1);
-  };
+  var frozenAtoms = new WeakSet();
   var deepFreeze = function deepFreeze(obj) {
     if (typeof obj !== 'object' || obj === null) return;
     Object.freeze(obj);
@@ -179060,23 +179071,39 @@
     return obj;
   };
   function freezeAtom(anAtom) {
-    return memo1$1(function () {
-      var frozenAtom = vanilla.atom(function (get) {
-        return deepFreeze(get(anAtom));
-      }, function (_get, set, arg) {
-        return set(anAtom, arg);
-      });
-      return frozenAtom;
-    }, anAtom);
+    if (frozenAtoms.has(anAtom)) {
+      return anAtom;
+    }
+    frozenAtoms.add(anAtom);
+    var origRead = anAtom.read;
+    anAtom.read = function (get, options) {
+      return deepFreeze(origRead.call(this, get, options));
+    };
+    if ('write' in anAtom) {
+      var origWrite = anAtom.write;
+      anAtom.write = function (get, set) {
+        for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+          args[_key - 2] = arguments[_key];
+        }
+        return origWrite.call.apply(origWrite, [this, get, function () {
+          for (var _len2 = arguments.length, setArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            setArgs[_key2] = arguments[_key2];
+          }
+          if (setArgs[0] === anAtom) {
+            setArgs[1] = deepFreeze(setArgs[1]);
+          }
+          return set.apply(void 0, setArgs);
+        }].concat(args));
+      };
+    }
+    return anAtom;
   }
   function freezeAtomCreator(createAtom) {
+    {
+      console.warn('[DEPRECATED] freezeAtomCreator is deprecated, define it on users end');
+    }
     return function () {
-      var anAtom = createAtom.apply(void 0, arguments);
-      var origRead = anAtom.read;
-      anAtom.read = function (get, options) {
-        return deepFreeze(origRead.call(this, get, options));
-      };
-      return anAtom;
+      return freezeAtom(createAtom.apply(void 0, arguments));
     };
   }
 
@@ -179343,9 +179370,7 @@
       baseAtom.debugPrivate = true;
     }
     baseAtom.onMount = function (setAtom) {
-      if (!getOnInit) {
-        setAtom(storage.getItem(key, initialValue));
-      }
+      setAtom(storage.getItem(key, initialValue));
       var unsub;
       if (storage.subscribe) {
         unsub = storage.subscribe(key, setAtom, initialValue);
@@ -179494,6 +179519,9 @@
   var memo1 = function memo1(create, dep1) {
     return (cache1$1.has(dep1) ? cache1$1 : cache1$1.set(dep1, create())).get(dep1);
   };
+  var isPromise$1 = function isPromise(x) {
+    return x instanceof Promise;
+  };
   var LOADING = {
     state: 'loading'
   };
@@ -179516,29 +179544,45 @@
             error: error
           };
         }
-        if (!(value instanceof Promise)) {
+        if (!isPromise$1(value)) {
           return {
             state: 'hasData',
             data: value
           };
         }
         var promise = value;
-        var cached = loadableCache.get(promise);
-        if (cached) {
-          return cached;
+        var cached1 = loadableCache.get(promise);
+        if (cached1) {
+          return cached1;
         }
-        loadableCache.set(promise, LOADING);
-        promise.then(function (data) {
+        if (promise.status === 'fulfilled') {
           loadableCache.set(promise, {
             state: 'hasData',
-            data: data
+            data: promise.value
           });
-        }, function (error) {
+        } else if (promise.status === 'rejected') {
           loadableCache.set(promise, {
             state: 'hasError',
-            error: error
+            error: promise.reason
           });
-        }).finally(setSelf);
+        } else {
+          promise.then(function (data) {
+            loadableCache.set(promise, {
+              state: 'hasData',
+              data: data
+            });
+          }, function (error) {
+            loadableCache.set(promise, {
+              state: 'hasError',
+              error: error
+            });
+          }).finally(setSelf);
+        }
+        var cached2 = loadableCache.get(promise);
+        if (cached2) {
+          return cached2;
+        }
+        loadableCache.set(promise, LOADING);
         return LOADING;
       }, function (_get, set) {
         set(refreshAtom, function (c) {
@@ -179564,6 +179608,9 @@
     }, cache1, dep1);
     return getCached(create, cache2, dep2);
   };
+  var isPromise = function isPromise(x) {
+    return x instanceof Promise;
+  };
   var defaultFallback = function defaultFallback() {
     return undefined;
   };
@@ -179583,28 +179630,32 @@
         get(refreshAtom);
         var prev = get(promiseAndValueAtom);
         var promise = get(anAtom);
-        if (!(promise instanceof Promise)) {
+        if (!isPromise(promise)) {
           return {
             v: promise
           };
         }
-        if (promise === (prev == null ? void 0 : prev.p)) {
-          if (promiseErrorCache.has(promise)) {
-            throw promiseErrorCache.get(promise);
-          }
-          if (promiseResultCache.has(promise)) {
-            return {
-              p: promise,
-              v: promiseResultCache.get(promise)
-            };
+        if (promise !== (prev == null ? void 0 : prev.p)) {
+          if (promise.status === 'fulfilled') {
+            promiseResultCache.set(promise, promise.value);
+          } else if (promise.status === 'rejected') {
+            promiseErrorCache.set(promise, promise.reason);
+          } else {
+            promise.then(function (v) {
+              return promiseResultCache.set(promise, v);
+            }, function (e) {
+              return promiseErrorCache.set(promise, e);
+            }).finally(setSelf);
           }
         }
-        if (promise !== (prev == null ? void 0 : prev.p)) {
-          promise.then(function (v) {
-            return promiseResultCache.set(promise, v);
-          }, function (e) {
-            return promiseErrorCache.set(promise, e);
-          }).finally(setSelf);
+        if (promiseErrorCache.has(promise)) {
+          throw promiseErrorCache.get(promise);
+        }
+        if (promiseResultCache.has(promise)) {
+          return {
+            p: promise,
+            v: promiseResultCache.get(promise)
+          };
         }
         if (prev && 'v' in prev) {
           return {
@@ -179641,11 +179692,46 @@
     }, anAtom, fallback);
   }
 
+  function atomWithRefresh(read, write) {
+    var refreshAtom = vanilla.atom(0);
+    {
+      refreshAtom.debugPrivate = true;
+    }
+    return vanilla.atom(function (get, options) {
+      get(refreshAtom);
+      return read(get, options);
+    }, function (get, set) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      if (args.length === 0) {
+        set(refreshAtom, function (c) {
+          return c + 1;
+        });
+      } else if (write) {
+        return write.apply(void 0, [get, set].concat(args));
+      }
+    });
+  }
+
+  function atomWithLazy(makeInitial) {
+    var a = vanilla.atom(undefined);
+    delete a.init;
+    Object.defineProperty(a, 'init', {
+      get: function get() {
+        return makeInitial();
+      }
+    });
+    return a;
+  }
+
   var RESET_1 = RESET;
   var atomFamily_1 = atomFamily;
   var atomWithDefault_1 = atomWithDefault;
+  var atomWithLazy_1 = atomWithLazy;
   var atomWithObservable_1 = atomWithObservable;
   var atomWithReducer_1 = atomWithReducer;
+  var atomWithRefresh_1 = atomWithRefresh;
   var atomWithReset_1 = atomWithReset;
   var atomWithStorage_1 = atomWithStorage;
   var createJSONStorage_1 = createJSONStorage;
@@ -179661,8 +179747,10 @@
   	RESET: RESET_1,
   	atomFamily: atomFamily_1,
   	atomWithDefault: atomWithDefault_1,
+  	atomWithLazy: atomWithLazy_1,
   	atomWithObservable: atomWithObservable_1,
   	atomWithReducer: atomWithReducer_1,
+  	atomWithRefresh: atomWithRefresh_1,
   	atomWithReset: atomWithReset_1,
   	atomWithStorage: atomWithStorage_1,
   	createJSONStorage: createJSONStorage_1,
@@ -179684,6 +179772,9 @@
   }
 
   function useReducerAtom(anAtom, reducer, options) {
+    {
+      console.warn('[DEPRECATED] useReducerAtom is deprecated and will be removed in the future. Please create your own version using the recipe. https://github.com/pmndrs/jotai/pull/2467');
+    }
     var _useAtom = react.useAtom(anAtom, options),
       state = _useAtom[0],
       setState = _useAtom[1];
@@ -209603,7 +209694,7 @@
   }
   // 检验当前运行环境
   if (typeof window === 'undefined') {
-    console.warn('cloud-business@0.1.114-5 仅支持在浏览器环境进行使用!');
+    console.warn('cloud-business@0.1.114-6 仅支持在浏览器环境进行使用!');
   }
   var bodys = document.getElementsByTagName('body')[0];
   var colors = [1, 2, 3, 4, 5, 6, 7];
@@ -209613,7 +209704,7 @@
       bodys.style.setProperty("--shuyunBlue".concat(i$2 + 1), color);
     }
   }
-  var version = '0.1.114-5';
+  var version = '0.1.114-6';
 
   exports.AreaSelector = AreaSelector;
   exports.AreaSelectorNew = AreaSelector$1;