@gaddario98/react-core 2.0.5 → 2.0.7

package/dist/pages/index.js

@@ -88,29 +88,22 @@ function getMountedOrPendingDependents(atom, atomState, mountedMap) {
   }
   return dependents;
 }
-const atomRead = (_store, atom, ...params) => atom.read(...params);
-const atomWrite = (_store, atom, ...params) => atom.write(...params);
-const atomOnInit = (store, atom) => {
-  if (atom.INTERNAL_onInit) {
-    return atom.INTERNAL_onInit(store);
-  }
-  if (atom.unstable_onInit) {
-    console.warn(
-      "[DEPRECATED] atom.unstable_onInit is renamed to atom.INTERNAL_onInit."
-    );
-    return atom.unstable_onInit(store);
-  }
+const BUILDING_BLOCK_atomRead = (_store, atom, ...params) => atom.read(...params);
+const BUILDING_BLOCK_atomWrite = (_store, atom, ...params) => atom.write(...params);
+const BUILDING_BLOCK_atomOnInit = (store, atom) => {
+  var _a;
+  return (_a = atom.INTERNAL_onInit) == null ? void 0 : _a.call(atom, store);
 };
-const atomOnMount = (_store, atom, setAtom) => {
+const BUILDING_BLOCK_atomOnMount = (_store, atom, setAtom) => {
   var _a;
   return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
 };
-const ensureAtomState = (store, atom) => {
+const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
   var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const atomStateMap = buildingBlocks[0];
   const storeHooks = buildingBlocks[6];
-  const atomOnInit2 = buildingBlocks[9];
+  const atomOnInit = buildingBlocks[9];
   if ((undefined ? undefined.MODE : void 0) !== "production" && !atom) {
     throw new Error("Atom is undefined or null");
   }
@@ -119,18 +112,18 @@ const ensureAtomState = (store, atom) => {
     atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
     atomStateMap.set(atom, atomState);
     (_a = storeHooks.i) == null ? void 0 : _a.call(storeHooks, atom);
-    atomOnInit2 == null ? void 0 : atomOnInit2(store, atom);
+    atomOnInit == null ? void 0 : atomOnInit(store, atom);
   }
   return atomState;
 };
-const flushCallbacks = (store) => {
+const BUILDING_BLOCK_flushCallbacks = (store) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const changedAtoms = buildingBlocks[3];
   const mountCallbacks = buildingBlocks[4];
   const unmountCallbacks = buildingBlocks[5];
   const storeHooks = buildingBlocks[6];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
   const errors = [];
   const call = (fn) => {
     try {
@@ -156,28 +149,28 @@ const flushCallbacks = (store) => {
     mountCallbacks.clear();
     callbacks.forEach(call);
     if (changedAtoms.size) {
-      recomputeInvalidatedAtoms2(store);
+      recomputeInvalidatedAtoms(store);
     }
   } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
   if (errors.length) {
     throw new AggregateError(errors);
   }
 };
-const recomputeInvalidatedAtoms = (store) => {
+const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
   const changedAtoms = buildingBlocks[3];
-  const ensureAtomState2 = buildingBlocks[11];
-  const readAtomState2 = buildingBlocks[14];
-  const mountDependencies2 = buildingBlocks[17];
+  const ensureAtomState = buildingBlocks[11];
+  const readAtomState = buildingBlocks[14];
+  const mountDependencies = buildingBlocks[17];
   const topSortedReversed = [];
   const visiting = /* @__PURE__ */ new WeakSet();
   const visited = /* @__PURE__ */ new WeakSet();
   const stack = Array.from(changedAtoms);
   while (stack.length) {
     const a = stack[stack.length - 1];
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     if (visited.has(a)) {
       stack.pop();
       continue;
@@ -209,35 +202,36 @@ const recomputeInvalidatedAtoms = (store) => {
       }
     }
     if (hasChangedDeps) {
-      readAtomState2(store, a);
-      mountDependencies2(store, a);
+      readAtomState(store, a);
+      mountDependencies(store, a);
     }
     invalidatedAtoms.delete(a);
   }
 };
 const storeMutationSet = /* @__PURE__ */ new WeakSet();
-const readAtomState = (store, atom) => {
+const BUILDING_BLOCK_readAtomState = (store, atom) => {
   var _a, _b;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const atomRead2 = buildingBlocks[7];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const writeAtomState2 = buildingBlocks[16];
-  const mountDependencies2 = buildingBlocks[17];
-  const atomState = ensureAtomState2(store, atom);
+  const atomRead = buildingBlocks[7];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const writeAtomState = buildingBlocks[16];
+  const mountDependencies = buildingBlocks[17];
+  const setAtomStateValueOrPromise = buildingBlocks[20];
+  const atomState = ensureAtomState(store, atom);
   if (isAtomStateInitialized(atomState)) {
     if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
       return atomState;
     }
     let hasChangedDeps = false;
     for (const [a, n] of atomState.d) {
-      if (readAtomState2(store, a).n !== n) {
+      if (readAtomState(store, a).n !== n) {
         hasChangedDeps = true;
         break;
       }
@@ -250,15 +244,15 @@ const readAtomState = (store, atom) => {
   let isSync = true;
   function mountDependenciesIfAsync() {
     if (mountedMap.has(atom)) {
-      mountDependencies2(store, atom);
-      recomputeInvalidatedAtoms2(store);
-      flushCallbacks2(store);
+      mountDependencies(store, atom);
+      recomputeInvalidatedAtoms(store);
+      flushCallbacks(store);
     }
   }
   function getter(a) {
     var _a2;
     if (a === atom) {
-      const aState2 = ensureAtomState2(store, a);
+      const aState2 = ensureAtomState(store, a);
       if (!isAtomStateInitialized(aState2)) {
         if (hasInitialValue(a)) {
           setAtomStateValueOrPromise(store, a, a.init);
@@ -268,7 +262,7 @@ const readAtomState = (store, atom) => {
       }
       return returnAtomValue(aState2);
     }
-    const aState = readAtomState2(store, a);
+    const aState = readAtomState(store, a);
     try {
       return returnAtomValue(aState);
     } finally {
@@ -294,6 +288,11 @@ const readAtomState = (store, atom) => {
       return controller.signal;
     },
     get setSelf() {
+      if ((undefined ? undefined.MODE : void 0) !== "production") {
+        console.warn(
+          "[DEPRECATED] setSelf is deprecated and will be removed in v3."
+        );
+      }
       if ((undefined ? undefined.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
         console.warn("setSelf function cannot be used with read-only atom");
       }
@@ -304,10 +303,10 @@ const readAtomState = (store, atom) => {
           }
           if (!isSync) {
             try {
-              return writeAtomState2(store, atom, ...args);
+              return writeAtomState(store, atom, ...args);
             } finally {
-              recomputeInvalidatedAtoms2(store);
-              flushCallbacks2(store);
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
             }
           }
         };
@@ -320,7 +319,7 @@ const readAtomState = (store, atom) => {
     if ((undefined ? undefined.MODE : void 0) !== "production") {
       storeMutationSet.delete(store);
     }
-    const valueOrPromise = atomRead2(store, atom, getter, options);
+    const valueOrPromise = atomRead(store, atom, getter, options);
     if ((undefined ? undefined.MODE : void 0) !== "production" && storeMutationSet.has(store)) {
       console.warn(
         "Detected store mutation during atom read. This is not supported."
@@ -347,38 +346,40 @@ const readAtomState = (store, atom) => {
     }
   }
 };
-const invalidateDependents = (store, atom) => {
+const BUILDING_BLOCK_invalidateDependents = (store, atom) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
-  const ensureAtomState2 = buildingBlocks[11];
+  const ensureAtomState = buildingBlocks[11];
   const stack = [atom];
   while (stack.length) {
     const a = stack.pop();
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      const dState = ensureAtomState2(store, d);
+      const dState = ensureAtomState(store, d);
       invalidatedAtoms.set(d, dState.n);
       stack.push(d);
     }
   }
 };
-const writeAtomState = (store, atom, ...args) => {
+const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const atomWrite2 = buildingBlocks[8];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const invalidateDependents2 = buildingBlocks[15];
-  const mountDependencies2 = buildingBlocks[17];
+  const atomWrite = buildingBlocks[8];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const invalidateDependents = buildingBlocks[15];
+  const writeAtomState = buildingBlocks[16];
+  const mountDependencies = buildingBlocks[17];
+  const setAtomStateValueOrPromise = buildingBlocks[20];
   let isSync = true;
-  const getter = (a) => returnAtomValue(readAtomState2(store, a));
+  const getter = (a) => returnAtomValue(readAtomState(store, a));
   const setter = (a, ...args2) => {
     var _a;
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     try {
       if (a === atom) {
         if (!hasInitialValue(a)) {
@@ -390,10 +391,10 @@ const writeAtomState = (store, atom, ...args) => {
         const prevEpochNumber = aState.n;
         const v = args2[0];
         setAtomStateValueOrPromise(store, a, v);
-        mountDependencies2(store, a);
+        mountDependencies(store, a);
         if (prevEpochNumber !== aState.n) {
           changedAtoms.add(a);
-          invalidateDependents2(store, a);
+          invalidateDependents(store, a);
           (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
         }
         return void 0;
@@ -402,39 +403,39 @@ const writeAtomState = (store, atom, ...args) => {
       }
     } finally {
       if (!isSync) {
-        recomputeInvalidatedAtoms2(store);
-        flushCallbacks2(store);
+        recomputeInvalidatedAtoms(store);
+        flushCallbacks(store);
       }
     }
   };
   try {
-    return atomWrite2(store, atom, getter, setter, ...args);
+    return atomWrite(store, atom, getter, setter, ...args);
   } finally {
     isSync = false;
   }
 };
-const mountDependencies = (store, atom) => {
+const BUILDING_BLOCK_mountDependencies = (store, atom) => {
   var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const ensureAtomState2 = buildingBlocks[11];
-  const invalidateDependents2 = buildingBlocks[15];
-  const mountAtom2 = buildingBlocks[18];
-  const unmountAtom2 = buildingBlocks[19];
-  const atomState = ensureAtomState2(store, atom);
+  const ensureAtomState = buildingBlocks[11];
+  const invalidateDependents = buildingBlocks[15];
+  const mountAtom = buildingBlocks[18];
+  const unmountAtom = buildingBlocks[19];
+  const atomState = ensureAtomState(store, atom);
   const mounted = mountedMap.get(atom);
   if (mounted && !isPendingPromise(atomState.v)) {
     for (const [a, n] of atomState.d) {
       if (!mounted.d.has(a)) {
-        const aState = ensureAtomState2(store, a);
-        const aMounted = mountAtom2(store, a);
+        const aState = ensureAtomState(store, a);
+        const aMounted = mountAtom(store, a);
         aMounted.t.add(atom);
         mounted.d.add(a);
         if (n !== aState.n) {
           changedAtoms.add(a);
-          invalidateDependents2(store, a);
+          invalidateDependents(store, a);
           (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
         }
       }
@@ -442,28 +443,29 @@ const mountDependencies = (store, atom) => {
     for (const a of mounted.d) {
       if (!atomState.d.has(a)) {
         mounted.d.delete(a);
-        const aMounted = unmountAtom2(store, a);
+        const aMounted = unmountAtom(store, a);
         aMounted == null ? void 0 : aMounted.t.delete(atom);
       }
     }
   }
 };
-const mountAtom = (store, atom) => {
+const BUILDING_BLOCK_mountAtom = (store, atom) => {
   var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const mountCallbacks = buildingBlocks[4];
   const storeHooks = buildingBlocks[6];
-  const atomOnMount2 = buildingBlocks[10];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const writeAtomState2 = buildingBlocks[16];
-  const atomState = ensureAtomState2(store, atom);
+  const atomOnMount = buildingBlocks[10];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const writeAtomState = buildingBlocks[16];
+  const mountAtom = buildingBlocks[18];
+  const atomState = ensureAtomState(store, atom);
   let mounted = mountedMap.get(atom);
   if (!mounted) {
-    readAtomState2(store, atom);
+    readAtomState(store, atom);
     for (const a of atomState.d.keys()) {
       const aMounted = mountAtom(store, a);
       aMounted.t.add(atom);
@@ -479,16 +481,16 @@ const mountAtom = (store, atom) => {
         let isSync = true;
         const setAtom = (...args) => {
           try {
-            return writeAtomState2(store, atom, ...args);
+            return writeAtomState(store, atom, ...args);
           } finally {
             if (!isSync) {
-              recomputeInvalidatedAtoms2(store);
-              flushCallbacks2(store);
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
             }
           }
         };
         try {
-          const onUnmount = atomOnMount2(store, atom, setAtom);
+          const onUnmount = atomOnMount(store, atom, setAtom);
           if (onUnmount) {
             mounted.u = () => {
               isSync = true;
@@ -509,15 +511,15 @@ const mountAtom = (store, atom) => {
   }
   return mounted;
 };
-const unmountAtom = (store, atom) => {
+const BUILDING_BLOCK_unmountAtom = (store, atom) => {
   var _a, _b;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const unmountCallbacks = buildingBlocks[5];
   const storeHooks = buildingBlocks[6];
-  const ensureAtomState2 = buildingBlocks[11];
-  const unmountAtom2 = buildingBlocks[19];
-  const atomState = ensureAtomState2(store, atom);
+  const ensureAtomState = buildingBlocks[11];
+  const unmountAtom = buildingBlocks[19];
+  const atomState = ensureAtomState(store, atom);
   let mounted = mountedMap.get(atom);
   if (!mounted || mounted.l.size) {
     return mounted;
@@ -536,7 +538,7 @@ const unmountAtom = (store, atom) => {
     mounted = void 0;
     mountedMap.delete(atom);
     for (const a of atomState.d.keys()) {
-      const aMounted = unmountAtom2(store, a);
+      const aMounted = unmountAtom(store, a);
       aMounted == null ? void 0 : aMounted.t.delete(atom);
     }
     (_b = storeHooks.u) == null ? void 0 : _b.call(storeHooks, atom);
@@ -544,9 +546,9 @@ const unmountAtom = (store, atom) => {
   }
   return mounted;
 };
-const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
-  const ensureAtomState2 = getInternalBuildingBlocks(store)[11];
-  const atomState = ensureAtomState2(store, atom);
+const BUILDING_BLOCK_setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
+  const ensureAtomState = getInternalBuildingBlocks(store)[11];
+  const atomState = ensureAtomState(store, atom);
   const hasPrevValue = "v" in atomState;
   const prevValue = atomState.v;
   if (isPromiseLike$1(valueOrPromise)) {
@@ -554,7 +556,7 @@ const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
       addPendingPromiseToDependency(
         atom,
         valueOrPromise,
-        ensureAtomState2(store, a)
+        ensureAtomState(store, a)
       );
     }
   }
@@ -567,35 +569,35 @@ const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
     }
   }
 };
-const storeGet = (store, atom) => {
-  const readAtomState2 = getInternalBuildingBlocks(store)[14];
-  return returnAtomValue(readAtomState2(store, atom));
+const BUILDING_BLOCK_storeGet = (store, atom) => {
+  const readAtomState = getInternalBuildingBlocks(store)[14];
+  return returnAtomValue(readAtomState(store, atom));
 };
-const storeSet = (store, atom, ...args) => {
+const BUILDING_BLOCK_storeSet = (store, atom, ...args) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const writeAtomState2 = buildingBlocks[16];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const writeAtomState = buildingBlocks[16];
   try {
-    return writeAtomState2(store, atom, ...args);
+    return writeAtomState(store, atom, ...args);
   } finally {
-    recomputeInvalidatedAtoms2(store);
-    flushCallbacks2(store);
+    recomputeInvalidatedAtoms(store);
+    flushCallbacks(store);
   }
 };
-const storeSub = (store, atom, listener) => {
+const BUILDING_BLOCK_storeSub = (store, atom, listener) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const mountAtom2 = buildingBlocks[18];
-  const unmountAtom2 = buildingBlocks[19];
-  const mounted = mountAtom2(store, atom);
+  const flushCallbacks = buildingBlocks[12];
+  const mountAtom = buildingBlocks[18];
+  const unmountAtom = buildingBlocks[19];
+  const mounted = mountAtom(store, atom);
   const listeners = mounted.l;
   listeners.add(listener);
-  flushCallbacks2(store);
+  flushCallbacks(store);
   return () => {
     listeners.delete(listener);
-    unmountAtom2(store, atom);
-    flushCallbacks2(store);
+    unmountAtom(store, atom);
+    flushCallbacks(store);
   };
 };
 const buildingBlockMap = /* @__PURE__ */ new WeakMap();
@@ -611,16 +613,16 @@ const getInternalBuildingBlocks = (store) => {
 function buildStore(...buildArgs) {
   const store = {
     get(atom) {
-      const storeGet2 = getInternalBuildingBlocks(store)[21];
-      return storeGet2(store, atom);
+      const storeGet = getInternalBuildingBlocks(store)[21];
+      return storeGet(store, atom);
     },
     set(atom, ...args) {
-      const storeSet2 = getInternalBuildingBlocks(store)[22];
-      return storeSet2(store, atom, ...args);
+      const storeSet = getInternalBuildingBlocks(store)[22];
+      return storeSet(store, atom, ...args);
     },
     sub(atom, listener) {
-      const storeSub2 = getInternalBuildingBlocks(store)[23];
-      return storeSub2(store, atom, listener);
+      const storeSub = getInternalBuildingBlocks(store)[23];
+      return storeSub(store, atom, listener);
     }
   };
   const buildingBlocks = [
@@ -640,24 +642,24 @@ function buildStore(...buildArgs) {
     {},
     // storeHooks
     // atom interceptors
-    atomRead,
-    atomWrite,
-    atomOnInit,
-    atomOnMount,
+    BUILDING_BLOCK_atomRead,
+    BUILDING_BLOCK_atomWrite,
+    BUILDING_BLOCK_atomOnInit,
+    BUILDING_BLOCK_atomOnMount,
     // building-block functions
-    ensureAtomState,
-    flushCallbacks,
-    recomputeInvalidatedAtoms,
-    readAtomState,
-    invalidateDependents,
-    writeAtomState,
-    mountDependencies,
-    mountAtom,
-    unmountAtom,
-    setAtomStateValueOrPromise,
-    storeGet,
-    storeSet,
-    storeSub,
+    BUILDING_BLOCK_ensureAtomState,
+    BUILDING_BLOCK_flushCallbacks,
+    BUILDING_BLOCK_recomputeInvalidatedAtoms,
+    BUILDING_BLOCK_readAtomState,
+    BUILDING_BLOCK_invalidateDependents,
+    BUILDING_BLOCK_writeAtomState,
+    BUILDING_BLOCK_mountDependencies,
+    BUILDING_BLOCK_mountAtom,
+    BUILDING_BLOCK_unmountAtom,
+    BUILDING_BLOCK_setAtomStateValueOrPromise,
+    BUILDING_BLOCK_storeGet,
+    BUILDING_BLOCK_storeSet,
+    BUILDING_BLOCK_storeSub,
     void 0
   ].map((fn, i) => buildArgs[i] || fn);
   buildingBlockMap.set(store, Object.freeze(buildingBlocks));
@@ -2472,10 +2474,11 @@ function resolveEnabled(enabled, query) {
   return typeof enabled === "function" ? enabled(query) : enabled;
 }
 var hasOwn = Object.prototype.hasOwnProperty;
-function replaceEqualDeep(a, b) {
+function replaceEqualDeep(a, b, depth = 0) {
   if (a === b) {
     return a;
   }
+  if (depth > 500) return b;
   const array = isPlainArray(a) && isPlainArray(b);
   if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
   const aItems = array ? a : Object.keys(a);
@@ -2497,7 +2500,7 @@ function replaceEqualDeep(a, b) {
       copy[key] = bItem;
       continue;
     }
-    const v = replaceEqualDeep(aItem, bItem);
+    const v = replaceEqualDeep(aItem, bItem, depth + 1);
     copy[key] = v;
     if (v === aItem) equalItems++;
   }
@@ -3090,10 +3093,12 @@ var QueryObserver = class extends Subscribable {
     };
     const nextResult = result;
     if (this.options.experimental_prefetchInRender) {
+      const hasResultData = nextResult.data !== void 0;
+      const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
       const finalizeThenableIfPossible = thenable => {
-        if (nextResult.status === "error") {
+        if (isErrorWithoutData) {
           thenable.reject(nextResult.error);
-        } else if (nextResult.data !== void 0) {
+        } else if (hasResultData) {
           thenable.resolve(nextResult.data);
         }
       };
@@ -3109,12 +3114,12 @@ var QueryObserver = class extends Subscribable {
           }
           break;
         case "fulfilled":
-          if (nextResult.status === "error" || nextResult.data !== prevThenable.value) {
+          if (isErrorWithoutData || nextResult.data !== prevThenable.value) {
             recreateThenable();
           }
           break;
         case "rejected":
-          if (nextResult.status !== "error" || nextResult.error !== prevThenable.reason) {
+          if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {
             recreateThenable();
           }
           break;