@legendapp/state 3.0.0-alpha.2 → 3.0.0-alpha.20

package/index.mjs

@@ -31,15 +31,20 @@ function isPromise(obj) {
 function isMap(obj) {
   return obj instanceof Map;
 }
+function isSet(obj) {
+  return obj instanceof Set;
+}
 function isNumber(obj) {
   const n = obj;
-  return n - n < 1;
+  return typeof n === "number" && n - n < 1;
 }
 function isEmpty(obj) {
   if (!obj)
     return false;
   if (isArray(obj))
     return obj.length === 0;
+  if (isMap(obj) || isSet(obj))
+    return obj.size === 0;
   for (const key in obj) {
     if (hasOwnProperty.call(obj, key)) {
       return false;
@@ -60,6 +65,7 @@ function isChildNodeValue(node) {
 
 // src/globals.ts
 var symbolToPrimitive = Symbol.toPrimitive;
+var symbolIterator = Symbol.iterator;
 var symbolGetNode = Symbol("getNode");
 var symbolDelete = /* @__PURE__ */ Symbol("delete");
 var symbolOpaque = Symbol("opaque");
@@ -67,7 +73,6 @@ var optimized = Symbol("optimized");
 var symbolLinked = Symbol("linked");
 var globalState = {
   isLoadingLocal: false,
-  isMerging: false,
   isLoadingRemote: false,
   activateSyncedNode: void 0,
   pendingNodes: /* @__PURE__ */ new Map(),
@@ -75,6 +80,9 @@ var globalState = {
   replacer: void 0,
   reviver: void 0
 };
+function isOpaqueObject(value) {
+  return value && (value[symbolOpaque] || value["$$typeof"]);
+}
 function getPathType(value) {
   return isArray(value) ? "array" : isMap(value) ? "map" : value instanceof Set ? "set" : "object";
 }
@@ -116,10 +124,10 @@ function reviver(key, value) {
   return value;
 }
 function safeStringify(value) {
-  return JSON.stringify(value, replacer);
+  return value ? JSON.stringify(value, replacer) : value;
 }
 function safeParse(value) {
-  return JSON.parse(value, reviver);
+  return value ? JSON.parse(value, reviver) : value;
 }
 function clone(value) {
   return safeParse(safeStringify(value));
@@ -135,7 +143,7 @@ function isEvent(value$) {
   return value$ && ((_a = value$[symbolGetNode]) == null ? void 0 : _a.isEvent);
 }
 function setNodeValue(node, newValue) {
-  var _a, _b, _c;
+  var _a;
   const parentNode = (_a = node.parent) != null ? _a : node;
   const key = node.parent ? node.key : "_";
   const isDelete = newValue === symbolDelete;
@@ -145,7 +153,7 @@ function setNodeValue(node, newValue) {
   const prevValue = parentValue[key];
   const isFunc = isFunction(newValue);
   newValue = !parentNode.isAssigning && isFunc && !isFunction(prevValue) ? newValue(prevValue) : newValue;
-  if (!globalState.isMerging || isNullOrUndefined(prevValue) || isFunction(prevValue) || !((_c = (_b = node.parent) == null ? void 0 : _b.functions) == null ? void 0 : _c.get(key))) {
+  if (newValue !== prevValue) {
     try {
       parentNode.isSetting = (parentNode.isSetting || 0) + 1;
       const useMapFn = isMap(parentValue);
@@ -283,10 +291,15 @@ function setAtPath(obj, path, pathTypes, value, mode, fullObj, restore) {
       } else if (o[p] === void 0 && value === void 0 && i === path.length - 1) {
         return obj;
       } else if (o[p] === void 0 || o[p] === null) {
-        o[p] = initializePathType(pathTypes[i]);
+        const child = initializePathType(pathTypes[i]);
+        if (isMap(o)) {
+          o.set(p, child);
+        } else {
+          o[p] = child;
+        }
       }
       if (i < path.length - 1) {
-        o = o[p];
+        o = isMap(o) ? o.get(p) : o[p];
         if (oFull) {
           oFull = oFull[p];
         }
@@ -295,13 +308,13 @@ function setAtPath(obj, path, pathTypes, value, mode, fullObj, restore) {
   }
   if (p === void 0) {
     if (mode === "merge") {
-      obj = _mergeIntoObservable(obj, value);
+      obj = deepMerge(obj, value, false, 0);
     } else {
       obj = value;
     }
   } else {
     if (mode === "merge") {
-      o[p] = _mergeIntoObservable(o[p], value);
+      o[p] = deepMerge(o[p], value, false, 0);
     } else if (isMap(o)) {
       o.set(p, value);
     } else {
@@ -332,48 +345,58 @@ function setInObservableAtPath(value$, path, pathTypes, value, mode) {
   }
 }
 function mergeIntoObservable(target, ...sources) {
+  if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
+    if (!isObservable(target)) {
+      console.error("[legend-state] should only use mergeIntoObservable with observables");
+    }
+  }
   beginBatch();
-  globalState.isMerging = true;
   for (let i = 0; i < sources.length; i++) {
-    target = _mergeIntoObservable(target, sources[i]);
+    _mergeIntoObservable(
+      target,
+      sources[i],
+      /*assign*/
+      i < sources.length - 1,
+      0
+    );
   }
-  globalState.isMerging = false;
   endBatch();
   return target;
 }
-function _mergeIntoObservable(target, source) {
-  var _a;
+function _mergeIntoObservable(target, source, assign2, levelsDeep) {
   if (isObservable(source)) {
     source = source.peek();
   }
-  const needsSet = isObservable(target);
-  const targetValue = needsSet ? target.peek() : target;
+  const targetValue = target.peek();
   const isTargetArr = isArray(targetValue);
   const isTargetObj = !isTargetArr && isObject(targetValue);
-  if (isTargetObj && isObject(source) && !isEmpty(targetValue) || isTargetArr && targetValue.length > 0) {
-    const keys = Object.keys(source);
+  const isSourceMap = isMap(source);
+  const isSourceSet = isSet(source);
+  if (isSourceSet && isSet(targetValue)) {
+    target.set(/* @__PURE__ */ new Set([...source, ...targetValue]));
+  } else if (isTargetObj && isObject(source) && !isEmpty(targetValue) || isTargetArr && targetValue.length > 0) {
+    const keys = isSourceMap || isSourceSet ? Array.from(source.keys()) : Object.keys(source);
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
-      const sourceValue = source[key];
+      const sourceValue = isSourceSet ? key : isSourceMap ? source.get(key) : source[key];
       if (sourceValue === symbolDelete) {
-        needsSet && ((_a = target[key]) == null ? void 0 : _a.delete) ? target[key].delete() : delete target[key];
+        target[key].delete();
       } else {
         const isObj = isObject(sourceValue);
         const isArr = !isObj && isArray(sourceValue);
         const targetChild = target[key];
-        if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
-          if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
-            target[key] = sourceValue;
-          } else {
-            _mergeIntoObservable(targetChild, sourceValue);
+        if ((isObj || isArr) && targetChild) {
+          if (levelsDeep > 0 && isEmpty(sourceValue)) {
+            targetChild.set(sourceValue);
           }
+          _mergeIntoObservable(targetChild, sourceValue, false, levelsDeep + 1);
         } else {
-          needsSet ? targetChild.set(sourceValue) : target[key] = sourceValue;
+          targetChild.set(sourceValue);
         }
       }
     }
   } else if (source !== void 0) {
-    needsSet ? target.set(source) : target = source;
+    target.set(source);
   }
   return target;
 }
@@ -428,6 +451,25 @@ function applyChanges(value, changes, applyPrevious) {
   }
   return value;
 }
+function deepMerge(target, ...sources) {
+  const result = { ...target };
+  for (let i = 0; i < sources.length; i++) {
+    const obj2 = sources[i];
+    for (const key in obj2) {
+      if (hasOwnProperty.call(obj2, key)) {
+        if (obj2[key] instanceof Object && !isObservable(obj2[key]) && Object.keys(obj2[key]).length > 0) {
+          result[key] = deepMerge(
+            result[key] || (isArray(obj2[key]) ? [] : {}),
+            obj2[key]
+          );
+        } else {
+          result[key] = obj2[key];
+        }
+      }
+    }
+  }
+  return result;
+}
 
 // src/batching.ts
 var timeout;
@@ -487,31 +529,35 @@ function notify(node, value, prev, level, whenOptimizedOnlyIf) {
     level,
     whenOptimizedOnlyIf
   );
-  if (changesInBatch.size) {
-    batchNotifyChanges(
-      changesInBatch,
-      /*immediate*/
-      true
-    );
-  }
   const existing = _batchMap.get(node);
   if (existing) {
-    existing.value = value;
+    if (existing.prev === value) {
+      _batchMap.delete(node);
+    } else {
+      existing.value = value;
+    }
   } else {
     _batchMap.set(node, {
       value,
       prev,
       level,
       whenOptimizedOnlyIf,
-      remote: globalState.isLoadingRemote,
-      loading: globalState.isLoadingLocal
+      isFromSync: globalState.isLoadingRemote,
+      isFromPersist: globalState.isLoadingLocal
     });
   }
+  if (changesInBatch.size) {
+    batchNotifyChanges(
+      changesInBatch,
+      /*immediate*/
+      true
+    );
+  }
   if (numInBatch <= 0) {
     runBatch();
   }
 }
-function computeChangesAtNode(changesInBatch, node, loading, remote, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
+function computeChangesAtNode(changesInBatch, node, isFromPersist, isFromSync, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
   if (immediate ? node.listenersImmediate : node.listeners) {
     const change = {
       path,
@@ -524,13 +570,14 @@ function computeChangesAtNode(changesInBatch, node, loading, remote, value, path
       const { changes } = changeInBatch;
       if (!isArraySubset(changes[0].path, change.path)) {
         changes.push(change);
+        changeInBatch.level = Math.min(changeInBatch.level, level);
       }
     } else {
       changesInBatch.set(node, {
         level,
         value,
-        remote,
-        loading,
+        isFromSync,
+        isFromPersist,
         whenOptimizedOnlyIf,
         changes: [change]
       });
@@ -594,7 +641,7 @@ function computeChangesRecursive(changesInBatch, node, loading, remote, value, p
 }
 function batchNotifyChanges(changesInBatch, immediate) {
   const listenersNotified = /* @__PURE__ */ new Set();
-  changesInBatch.forEach(({ changes, level, value, loading, remote, whenOptimizedOnlyIf }, node) => {
+  changesInBatch.forEach(({ changes, level, value, isFromPersist, isFromSync, whenOptimizedOnlyIf }, node) => {
     const listeners = immediate ? node.listenersImmediate : node.listeners;
     if (listeners) {
       let listenerParams;
@@ -608,8 +655,8 @@ function batchNotifyChanges(changesInBatch, immediate) {
             if (!noArgs && !listenerParams) {
               listenerParams = {
                 value,
-                loading,
-                remote,
+                isFromPersist,
+                isFromSync,
                 getPrevious: createPreviousHandler(value, changes),
                 changes
               };
@@ -637,12 +684,12 @@ function runBatch() {
   const map = _batchMap;
   _batchMap = /* @__PURE__ */ new Map();
   const changesInBatch = /* @__PURE__ */ new Map();
-  map.forEach(({ value, prev, level, loading, remote, whenOptimizedOnlyIf }, node) => {
+  map.forEach(({ value, prev, level, isFromPersist, isFromSync, whenOptimizedOnlyIf }, node) => {
     computeChangesRecursive(
       changesInBatch,
       node,
-      loading,
-      remote,
+      isFromPersist,
+      isFromSync,
       value,
       [],
       [],
@@ -701,21 +748,6 @@ function getNodeAtPath(obj, path) {
   return o;
 }
 
-// src/linked.ts
-function linked(params, options) {
-  if (isFunction(params)) {
-    params = { get: params };
-  }
-  if (options) {
-    params = { ...params, ...options };
-  }
-  const ret = function() {
-    return { [symbolLinked]: params };
-  };
-  ret.prototype[symbolLinked] = params;
-  return ret;
-}
-
 // src/createObservable.ts
 function createObservable(value, makePrimitive, extractPromise2, createObject, createPrimitive) {
   if (isObservable(value)) {
@@ -745,6 +777,21 @@ function createObservable(value, makePrimitive, extractPromise2, createObject, c
   return obs;
 }
 
+// src/linked.ts
+function linked(params, options) {
+  if (isFunction(params)) {
+    params = { get: params };
+  }
+  if (options) {
+    params = { ...params, ...options };
+  }
+  const ret = function() {
+    return { [symbolLinked]: params };
+  };
+  ret.prototype[symbolLinked] = params;
+  return ret;
+}
+
 // src/onChange.ts
 function onChange(node, callback, options = {}, fromLinks) {
   var _a;
@@ -769,8 +816,8 @@ function onChange(node, callback, options = {}, fromLinks) {
     const value = getNodeValue(node);
     callback({
       value,
-      loading: true,
-      remote: false,
+      isFromPersist: true,
+      isFromSync: false,
       changes: [
         {
           path: [],
@@ -827,13 +874,13 @@ function onChange(node, callback, options = {}, fromLinks) {
 }
 function createCb(linkedFromNode, path, callback) {
   let { valueAtPath: prevAtPath } = getValueAtPath2(getNodeValue(linkedFromNode), path);
-  return function({ value: valueA, loading, remote }) {
+  return function({ value: valueA, isFromPersist, isFromSync }) {
     const { valueAtPath } = getValueAtPath2(valueA, path);
     if (valueAtPath !== prevAtPath) {
       callback({
         value: valueAtPath,
-        loading,
-        remote,
+        isFromPersist,
+        isFromSync,
         changes: [
           {
             path: [],
@@ -953,12 +1000,17 @@ function observe(selectorOrRun, reactionOrOptions, options) {
     options = reactionOrOptions;
   }
   let dispose;
+  let isRunning = false;
   const e = { num: 0 };
   const update = function() {
+    if (isRunning) {
+      return;
+    }
     if (e.onCleanup) {
       e.onCleanup();
       e.onCleanup = void 0;
     }
+    isRunning = true;
     beginBatch();
     delete e.value;
     dispose == null ? void 0 : dispose();
@@ -972,6 +1024,7 @@ function observe(selectorOrRun, reactionOrOptions, options) {
       e.onCleanupReaction = void 0;
     }
     endBatch();
+    isRunning = false;
     if (reaction && ((options == null ? void 0 : options.fromComputed) || (e.num > 0 || !isEvent(selectorOrRun)) && (e.previous !== e.value || typeof e.value === "object"))) {
       reaction(e);
     }
@@ -1108,7 +1161,7 @@ function updateNodes(parent, obj, prevValue) {
     }
     __devUpdateNodes.add(obj);
   }
-  if (isObject(obj) && obj[symbolOpaque] || isObject(prevValue) && prevValue[symbolOpaque]) {
+  if (isObject(obj) && isOpaqueObject(obj) || isObject(prevValue) && isOpaqueObject(prevValue)) {
     const isDiff = obj !== prevValue;
     if (isDiff) {
       if (parent.listeners || parent.listenersImmediate) {
@@ -1296,10 +1349,10 @@ var proxyHandler = {
     if (p === symbolGetNode) {
       return node;
     }
-    if (p === "apply") {
+    if (p === "apply" || p === "call") {
       const nodeValue = getNodeValue(node);
       if (isFunction(nodeValue)) {
-        return nodeValue.apply;
+        return nodeValue[p];
       }
     }
     let value = peekInternal(
@@ -1307,6 +1360,9 @@ var proxyHandler = {
       /*activateRecursive*/
       p === "get" || p === "peek"
     );
+    if (p === symbolIterator) {
+      return !value || isPrimitive(value) ? void 0 : value[p];
+    }
     const targetNode = node.linkedToNode || (value == null ? void 0 : value[symbolGetNode]);
     if (targetNode && p !== "onChange") {
       return proxyHandler.get(targetNode, p, receiver);
@@ -1341,7 +1397,7 @@ var proxyHandler = {
       return property.get(node);
     }
     let vProp = value == null ? void 0 : value[p];
-    if (isObject(value) && value[symbolOpaque]) {
+    if (isObject(value) && isOpaqueObject(value)) {
       return vProp;
     }
     const fnOrComputed = (_a = node.functions) == null ? void 0 : _a.get(p);
@@ -1507,11 +1563,17 @@ function setKey(node, key, newValue, level) {
   } else {
     const { newValue: savedValue, prevValue } = setNodeValue(childNode, newValue);
     const isPrim = isPrimitive(savedValue) || savedValue instanceof Date;
-    if (!equals(savedValue, prevValue)) {
-      updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level);
-    }
     if (!isPrim) {
-      childNode.needsExtract = true;
+      let parent = childNode;
+      do {
+        parent.needsExtract = true;
+        parent.recursivelyAutoActivated = false;
+      } while (parent = parent.parent);
+    }
+    const notify2 = !equals(savedValue, prevValue);
+    const forceNotify = !notify2 && childNode.isComputing && !isPrim;
+    if (notify2 || forceNotify) {
+      updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level, forceNotify);
     }
     extractFunctionOrComputed(node, key, savedValue);
   }
@@ -1526,6 +1588,8 @@ function assign(node, value) {
     const currentValue = getNodeValue(node);
     if (isMap(currentValue)) {
       value.forEach((value2, key) => currentValue.set(key, value2));
+    } else {
+      set(node, value);
     }
   } else {
     node.isAssigning = (node.isAssigning || 0) + 1;
@@ -1622,20 +1686,20 @@ function handlerMapSet(node, p, value) {
     };
   }
 }
-function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRoot, level) {
+function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRoot, level, forceNotify) {
   if (!childNode)
     childNode = node;
   beginBatch();
   if (isPrim === void 0) {
     isPrim = isPrimitive(newValue);
   }
-  let hasADiff = isPrim;
+  let hasADiff = forceNotify || isPrim;
   let whenOptimizedOnlyIf = false;
   if (!isPrim || prevValue && !isPrimitive(prevValue)) {
     if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined") {
       __devUpdateNodes.clear();
     }
-    hasADiff = updateNodes(childNode, newValue, prevValue);
+    hasADiff = hasADiff || updateNodes(childNode, newValue, prevValue);
     if (isArray(newValue)) {
       whenOptimizedOnlyIf = (newValue == null ? void 0 : newValue.length) !== (prevValue == null ? void 0 : prevValue.length);
     }
@@ -1652,6 +1716,7 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
   endBatch();
 }
 function extractPromise(node, value, setter) {
+  const numGets = node.numGets = (node.numGets || 0) + 1;
   if (!node.state) {
     node.state = createObservable(
       {
@@ -1663,11 +1728,14 @@ function extractPromise(node, value, setter) {
     );
   }
   value.then((value2) => {
-    setter ? setter({ value: value2 }) : set(node, value2);
-    node.state.assign({
-      isLoaded: true,
-      error: void 0
-    });
+    if (numGets >= (node.getNumResolved || 0)) {
+      node.getNumResolved = node.numGets;
+      setter ? setter({ value: value2 }) : set(node, value2);
+      node.state.assign({
+        isLoaded: true,
+        error: void 0
+      });
+    }
   }).catch((error) => {
     node.state.error.set(error);
   });
@@ -1684,6 +1752,7 @@ function extractFunctionOrComputed(node, k, v) {
     const childNode = getChildNode(node, k, fn);
     const targetNode = getNode(v);
     const initialValue = peek(targetNode);
+    setToObservable(childNode, v);
     setNodeValue(childNode, initialValue);
     return getNodeValue(childNode);
   } else if (typeof v === "function") {
@@ -1716,7 +1785,9 @@ function peekInternal(node, activateRecursive) {
   }
   isFlushing = false;
   let value = getNodeValue(node);
-  value = checkLazy(node, value, !!activateRecursive);
+  if (!globalState.isLoadingLocal) {
+    value = checkLazy(node, value, !!activateRecursive);
+  }
   return value;
 }
 function checkLazy(node, value, activateRecursive) {
@@ -1731,10 +1802,12 @@ function checkLazy(node, value, activateRecursive) {
       } else {
         if (node.parent) {
           const parentValue = getNodeValue(node.parent);
-          if (parentValue) {
-            delete parentValue[node.key];
-          } else {
-            node.root._ = void 0;
+          if (isFunction(value)) {
+            if (parentValue) {
+              delete parentValue[node.key];
+            } else {
+              node.root._ = void 0;
+            }
           }
         }
         value = activateNodeFunction(node, lazyFn);
@@ -1823,7 +1896,9 @@ function activateNodeFunction(node, lazyFn) {
       var _a, _b, _c, _d;
       if (isFirst) {
         isFirst = false;
-        setNodeValue(node, void 0);
+        if (isFunction(getNodeValue(node))) {
+          setNodeValue(node, void 0);
+        }
       } else if (!isFlushing && refreshFn) {
         if (shouldIgnoreUnobserved(node, refreshFn)) {
           ignoreThisUpdate = true;
@@ -1836,7 +1911,7 @@ function activateNodeFunction(node, lazyFn) {
         didSetToObs = true;
         value = setToObservable(node, value);
       }
-      if (isFunction(value)) {
+      if (isFunction(value) && value.length === 0) {
         value = value();
       }
       const activated = !isObservable(value) ? value == null ? void 0 : value[symbolLinked] : void 0;
@@ -1894,16 +1969,14 @@ function activateNodeFunction(node, lazyFn) {
             }
           } else {
             activatedValue = value;
-            if (node.state.isLoaded.peek()) {
+            const isLoaded = node.state.isLoaded.peek();
+            if (isLoaded || !isFunction(value)) {
               node.isComputing = true;
               set(node, value);
               node.isComputing = false;
-            } else {
-              setNodeValue(node, value);
-              node.state.assign({
-                isLoaded: true,
-                error: void 0
-              });
+            }
+            if (!isLoaded) {
+              node.state.assign({ isLoaded: true, error: void 0 });
             }
           }
         }
@@ -1944,14 +2017,14 @@ function activateNodeBase(node, value) {
         if (allChanges.length > 0) {
           let changes;
           let value2;
-          let loading = false;
-          let remote = false;
+          let isFromPersist = false;
+          let isFromSync = false;
           let getPrevious;
           if (listenerParams) {
             changes = listenerParams.changes;
             value2 = listenerParams.value;
-            loading = listenerParams.loading;
-            remote = listenerParams.remote;
+            isFromPersist = listenerParams.isFromPersist;
+            isFromSync = listenerParams.isFromSync;
             getPrevious = listenerParams.getPrevious;
           } else {
             changes = allChanges;
@@ -1971,8 +2044,8 @@ function activateNodeBase(node, value) {
             setFn({
               value: value2,
               changes,
-              loading,
-              remote,
+              isFromPersist,
+              isFromSync,
               getPrevious
             });
             node.isComputing = false;
@@ -2017,7 +2090,9 @@ function setToObservable(node, value) {
       linkedNode,
       () => {
         value = peekInternal(linkedNode);
-        set(node, value);
+        if (!isFunction(value)) {
+          set(node, value);
+        }
       },
       { initial: true },
       /* @__PURE__ */ new Set([node])
@@ -2026,7 +2101,8 @@ function setToObservable(node, value) {
   return value;
 }
 function recursivelyAutoActivate(obj, node) {
-  if (isObject(obj) || isArray(obj)) {
+  if (!node.recursivelyAutoActivated && (isObject(obj) || isArray(obj)) && !isOpaqueObject(obj)) {
+    node.recursivelyAutoActivated = true;
     const pathStack = [];
     const getNodeAtPath2 = () => {
       var _a;
@@ -2044,27 +2120,29 @@ function recursivelyAutoActivate(obj, node) {
 }
 function recursivelyAutoActivateInner(obj, pathStack, getNodeAtPath2) {
   var _a;
-  for (const key in obj) {
-    if (hasOwnProperty.call(obj, key)) {
-      const value = obj[key];
-      if (isObservable(value)) {
-        const childNode = getNodeAtPath2();
-        extractFunctionOrComputed(childNode, key, value);
-        delete childNode.lazy;
-      } else {
-        const linkedOptions = isFunction(value) && ((_a = value.prototype) == null ? void 0 : _a[symbolLinked]);
-        if (linkedOptions) {
-          const activate = linkedOptions.activate;
-          if (!activate || activate === "auto") {
-            const childNode = getNodeAtPath2();
-            peek(getChildNode(childNode, key, value));
+  if ((isObject(obj) || isArray(obj)) && !isOpaqueObject(obj)) {
+    for (const key in obj) {
+      if (hasOwnProperty.call(obj, key)) {
+        const value = obj[key];
+        if (isObservable(value)) {
+          const childNode = getNodeAtPath2();
+          extractFunctionOrComputed(childNode, key, value);
+          delete childNode.lazy;
+        } else {
+          const linkedOptions = isFunction(value) && ((_a = value.prototype) == null ? void 0 : _a[symbolLinked]);
+          if (linkedOptions) {
+            const activate = linkedOptions.activate;
+            if (!activate || activate === "auto") {
+              const childNode = getNodeAtPath2();
+              peek(getChildNode(childNode, key, value));
+            }
           }
         }
-      }
-      if (typeof value === "object") {
-        pathStack.push({ key, value });
-        recursivelyAutoActivateInner(value, pathStack, getNodeAtPath2);
-        pathStack.pop();
+        if (typeof value === "object") {
+          pathStack.push({ key, value });
+          recursivelyAutoActivateInner(value, pathStack, getNodeAtPath2);
+          pathStack.pop();
+        }
       }
     }
   }
@@ -2120,16 +2198,6 @@ function observable(value) {
 function observablePrimitive(value) {
   return createObservable(value, true, extractPromise, getProxy, ObservablePrimitiveClass);
 }
-function syncState(obs) {
-  const node = getNode(obs);
-  if (!node.state) {
-    peekInternal(node);
-  }
-  if (!node.state) {
-    node.state = observable({});
-  }
-  return node.state;
-}
 
 // src/computed.ts
 function computed(get2, set2) {
@@ -2207,54 +2275,63 @@ function proxy(get2, set2) {
   );
 }
 
+// src/syncState.ts
+function syncState(obs) {
+  const node = getNode(obs);
+  if (!node.state) {
+    node.state = observable({
+      isPersistLoaded: false,
+      isLoaded: false,
+      isPersistEnabled: true,
+      isSyncEnabled: true,
+      isGetting: false,
+      isSetting: false,
+      numPendingSets: 0,
+      syncCount: 0,
+      clearPersist: void 0,
+      sync: () => Promise.resolve(),
+      getPendingChanges: () => ({})
+    });
+  }
+  return node.state;
+}
+
 // src/retry.ts
-function calculateRetryDelay(retryOptions, attemptNum) {
+function calculateRetryDelay(retryOptions, retryNum) {
   const { backoff, delay = 1e3, infinite, times = 3, maxDelay = 3e4 } = retryOptions;
-  if (infinite || attemptNum < times) {
-    const delayTime = Math.min(delay * (backoff === "constant" ? 1 : 2 ** attemptNum), maxDelay);
+  if (infinite || retryNum < times) {
+    const delayTime = Math.min(delay * (backoff === "constant" ? 1 : 2 ** retryNum), maxDelay);
     return delayTime;
   }
   return null;
 }
-function createRetryTimeout(retryOptions, attemptNum, fn) {
-  const delayTime = calculateRetryDelay(retryOptions, attemptNum);
+function createRetryTimeout(retryOptions, retryNum, fn) {
+  const delayTime = calculateRetryDelay(retryOptions, retryNum);
   if (delayTime) {
     return setTimeout(fn, delayTime);
   }
 }
-function runWithRetry(node, state, fn) {
-  const { waitFor } = node.activationState;
+function runWithRetry(state, fn) {
   const { retry } = state;
-  const e = { cancel: false };
-  let value = void 0;
-  if (waitFor) {
-    value = whenReady(waitFor, () => {
-      node.activationState.waitFor = void 0;
-      return fn(e);
-    });
-  } else {
-    value = fn(e);
-  }
+  const e = Object.assign(state, { cancel: false, cancelRetry: () => e.cancel = false });
+  let value = fn(e);
   if (isPromise(value) && retry) {
     let timeoutRetry;
     return new Promise((resolve) => {
       const run = () => {
         value.then((val) => {
-          node.activationState.persistedRetry = false;
           resolve(val);
         }).catch(() => {
-          state.attemptNum++;
+          state.retryNum++;
           if (timeoutRetry) {
             clearTimeout(timeoutRetry);
           }
           if (!e.cancel) {
-            timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
+            timeoutRetry = createRetryTimeout(retry, state.retryNum, () => {
               value = fn(e);
               run();
             });
           }
-        }).finally(() => {
-          node.activationState.persistedRetry = false;
         });
       };
       run();
@@ -2267,6 +2344,7 @@ function runWithRetry(node, state, fn) {
 var internal = {
   createPreviousHandler,
   clone,
+  deepMerge,
   ensureNodeValue,
   findIDKey,
   get,