@legendapp/state 3.0.0-alpha.3 → 3.0.0-alpha.30

package/index.js

@@ -31,17 +31,22 @@ function isPromise(obj) {
   return obj instanceof Promise;
 }
 function isMap(obj) {
-  return obj instanceof Map;
+  return obj instanceof Map || obj instanceof WeakMap;
+}
+function isSet(obj) {
+  return obj instanceof Set || obj instanceof WeakSet;
 }
 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;
@@ -56,27 +61,25 @@ var setPrimitives = /* @__PURE__ */ new Set(["boolean", "string", "number"]);
 function isActualPrimitive(arg) {
   return setPrimitives.has(typeof arg);
 }
-function isChildNodeValue(node) {
+function isChildNode(node) {
   return !!node.parent;
 }
 
 // src/globals.ts
 var symbolToPrimitive = Symbol.toPrimitive;
+var symbolIterator = Symbol.iterator;
 var symbolGetNode = Symbol("getNode");
 var symbolDelete = /* @__PURE__ */ Symbol("delete");
 var symbolOpaque = Symbol("opaque");
 var optimized = Symbol("optimized");
 var symbolLinked = Symbol("linked");
 var globalState = {
-  isLoadingLocal: false,
-  isMerging: false,
-  isLoadingRemote: false,
-  activateSyncedNode: void 0,
   pendingNodes: /* @__PURE__ */ new Map(),
-  dirtyNodes: /* @__PURE__ */ new Set(),
-  replacer: void 0,
-  reviver: void 0
+  dirtyNodes: /* @__PURE__ */ new Set()
 };
+function isOpaqueObject(value) {
+  return value && (value[symbolOpaque] || value["$$typeof"]);
+}
 function getPathType(value) {
   return isArray(value) ? "array" : isMap(value) ? "map" : value instanceof Set ? "set" : "object";
 }
@@ -118,10 +121,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));
@@ -137,29 +140,31 @@ 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;
   if (isDelete)
     newValue = void 0;
   const parentValue = node.parent ? ensureNodeValue(parentNode) : parentNode.root;
-  const prevValue = parentValue[key];
+  const useSetFn = isSet(parentValue);
+  const useMapFn = isMap(parentValue);
+  const prevValue = useSetFn ? key : useMapFn ? parentValue.get(key) : 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);
       if (isDelete) {
-        if (useMapFn) {
+        if (useMapFn || useSetFn) {
           parentValue.delete(key);
         } else {
           delete parentValue[key];
         }
       } else {
-        const useMapFn2 = isMap(parentValue);
-        if (useMapFn2) {
+        if (useSetFn) {
+          parentValue.add(newValue);
+        } else if (useMapFn) {
           parentValue.set(key, newValue);
         } else {
           parentValue[key] = newValue;
@@ -175,7 +180,7 @@ var arrNodeKeys = [];
 function getNodeValue(node) {
   let count = 0;
   let n = node;
-  while (isChildNodeValue(n)) {
+  while (isChildNode(n)) {
     arrNodeKeys[count++] = n.key;
     n = n.parent;
   }
@@ -215,7 +220,7 @@ function getChildNode(node, key, asFunction) {
 function ensureNodeValue(node) {
   let value = getNodeValue(node);
   if (!value || isFunction(value)) {
-    if (isChildNodeValue(node)) {
+    if (isChildNode(node)) {
       const parent = ensureNodeValue(node.parent);
       value = parent[node.key] = {};
     } else {
@@ -284,11 +289,16 @@ function setAtPath(obj, path, pathTypes, value, mode, fullObj, restore) {
         return obj;
       } 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]);
+      } else if (i < path.length - 1 && (o[p] === void 0 || o[p] === null)) {
+        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];
         }
@@ -297,13 +307,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);
     } else {
       obj = value;
     }
   } else {
     if (mode === "merge") {
-      o[p] = _mergeIntoObservable(o[p], value);
+      o[p] = deepMerge(o[p], value);
     } else if (isMap(o)) {
       o.set(p, value);
     } else {
@@ -312,80 +322,59 @@ function setAtPath(obj, path, pathTypes, value, mode, fullObj, restore) {
   }
   return obj;
 }
-function setInObservableAtPath(value$, path, pathTypes, value, mode) {
-  let o = value$;
-  let v = value;
-  for (let i = 0; i < path.length; i++) {
-    const p = path[i];
-    if (!o.peek()[p]) {
-      o[p].set(initializePathType(pathTypes[i]));
-    }
-    o = o[p];
-    v = v[p];
-  }
-  if (v === symbolDelete) {
-    o.delete();
-  } else if (mode === "assign" && o.assign && isObject(o.peek())) {
-    o.assign(v);
-  } else if (mode === "merge") {
-    mergeIntoObservable(o, v);
-  } else {
-    o.set(v);
-  }
-}
 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(
+    _mergeIntoObservable(
       target,
       sources[i],
       /*assign*/
-      i < sources.length - 1
+      i < sources.length - 1,
+      0
     );
   }
-  globalState.isMerging = false;
   endBatch();
   return target;
 }
-function _mergeIntoObservable(target, source, assign2) {
-  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] = assign2 ? isArr ? [...sourceValue] : { ...sourceValue } : sourceValue;
-          } else {
-            _mergeIntoObservable(targetChild, sourceValue);
-          }
-        } else {
-          if (needsSet) {
+        if ((isObj || isArr) && targetChild) {
+          if (levelsDeep > 0 && isEmpty(sourceValue)) {
             targetChild.set(sourceValue);
-          } else {
-            const toSet = isObject(sourceValue) ? { ...sourceValue } : isArray(sourceValue) ? [...sourceValue] : sourceValue;
-            target[key] = toSet;
           }
+          _mergeIntoObservable(targetChild, sourceValue, false, levelsDeep + 1);
+        } else {
+          targetChild.set(sourceValue);
         }
       }
     }
   } else if (source !== void 0) {
-    needsSet ? target.set(source) : target = assign2 ? isArray(source) ? [...source] : { ...source } : source;
+    target.set(source);
   }
   return target;
 }
@@ -422,12 +411,13 @@ function initializePathType(pathType) {
   switch (pathType) {
     case "array":
       return [];
-    case "object":
-      return {};
     case "map":
       return /* @__PURE__ */ new Map();
     case "set":
       return /* @__PURE__ */ new Set();
+    case "object":
+    default:
+      return {};
   }
 }
 function applyChange(value, change, applyPrevious) {
@@ -440,6 +430,33 @@ function applyChanges(value, changes, applyPrevious) {
   }
   return value;
 }
+function deepMerge(target, ...sources) {
+  if (isPrimitive(target)) {
+    return sources[sources.length - 1];
+  }
+  let result = isArray(target) ? [...target] : { ...target };
+  for (let i = 0; i < sources.length; i++) {
+    const obj2 = sources[i];
+    if (isObject(obj2) || isArray(obj2)) {
+      const objTarget = obj2;
+      for (const key in objTarget) {
+        if (hasOwnProperty.call(objTarget, key)) {
+          if (objTarget[key] instanceof Object && !isObservable(objTarget[key]) && Object.keys(objTarget[key]).length > 0) {
+            result[key] = deepMerge(
+              result[key] || (isArray(objTarget[key]) ? [] : {}),
+              objTarget[key]
+            );
+          } else {
+            result[key] = objTarget[key];
+          }
+        }
+      }
+    } else {
+      result = obj2;
+    }
+  }
+  return result;
+}
 
 // src/batching.ts
 var timeout;
@@ -486,9 +503,9 @@ function notify(node, value, prev, level, whenOptimizedOnlyIf) {
     changesInBatch,
     node,
     /*loading*/
-    globalState.isLoadingLocal,
+    !!globalState.isLoadingLocal,
     /*remote*/
-    globalState.isLoadingRemote,
+    !!globalState.isLoadingRemote,
     value,
     [],
     [],
@@ -499,31 +516,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,
@@ -536,13 +557,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]
       });
@@ -606,7 +628,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;
@@ -620,8 +642,8 @@ function batchNotifyChanges(changesInBatch, immediate) {
             if (!noArgs && !listenerParams) {
               listenerParams = {
                 value,
-                loading,
-                remote,
+                isFromPersist,
+                isFromSync,
                 getPrevious: createPreviousHandler(value, changes),
                 changes
               };
@@ -649,12 +671,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,
       [],
       [],
@@ -713,21 +735,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)) {
@@ -757,6 +764,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;
@@ -781,8 +803,8 @@ function onChange(node, callback, options = {}, fromLinks) {
     const value = getNodeValue(node);
     callback({
       value,
-      loading: true,
-      remote: false,
+      isFromPersist: true,
+      isFromSync: false,
       changes: [
         {
           path: [],
@@ -838,14 +860,14 @@ function onChange(node, callback, options = {}, fromLinks) {
   };
 }
 function createCb(linkedFromNode, path, callback) {
-  let { valueAtPath: prevAtPath } = getValueAtPath2(getNodeValue(linkedFromNode), path);
-  return function({ value: valueA, loading, remote }) {
-    const { valueAtPath } = getValueAtPath2(valueA, path);
+  let prevAtPath = deconstructObjectWithPath(path, [], getNodeValue(linkedFromNode));
+  return function({ value: valueA, isFromPersist, isFromSync }) {
+    const valueAtPath = deconstructObjectWithPath(path, [], valueA);
     if (valueAtPath !== prevAtPath) {
       callback({
         value: valueAtPath,
-        loading,
-        remote,
+        isFromPersist,
+        isFromSync,
         changes: [
           {
             path: [],
@@ -860,16 +882,6 @@ function createCb(linkedFromNode, path, callback) {
     prevAtPath = valueAtPath;
   };
 }
-function getValueAtPath2(obj, path) {
-  let o = obj;
-  const pathTypes = [];
-  for (let i = 0; o && i < path.length; i++) {
-    pathTypes.push(isArray(o) ? "array" : "object");
-    const p = path[i];
-    o = o[p];
-  }
-  return { valueAtPath: o, pathTypes };
-}
 
 // src/setupTracking.ts
 function setupTracking(nodes, update, noArgs, immediate) {
@@ -965,12 +977,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();
@@ -984,6 +1001,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);
     }
@@ -1067,6 +1085,7 @@ var ArrayLoopers = /* @__PURE__ */ new Set([
   "filter",
   "find",
   "findIndex",
+  "flatMap",
   "forEach",
   "join",
   "map",
@@ -1096,7 +1115,7 @@ function collectionSetter(node, target, prop, ...args) {
     const prevValue = target.slice();
     const ret = target[prop].apply(target, args);
     if (node) {
-      const hasParent = isChildNodeValue(node);
+      const hasParent = isChildNode(node);
       const key = hasParent ? node.key : "_";
       const parentValue = hasParent ? getNodeValue(node.parent) : node.root;
       parentValue[key] = prevValue;
@@ -1120,7 +1139,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) {
@@ -1308,10 +1327,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(
@@ -1319,11 +1338,14 @@ 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);
     }
-    if (isMap(value) || value instanceof WeakMap || value instanceof Set || value instanceof WeakSet) {
+    if (isMap(value) || isSet(value)) {
       const ret = handlerMapSet(node, p, value);
       if (ret !== void 0) {
         return ret;
@@ -1353,7 +1375,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);
@@ -1415,7 +1437,7 @@ var proxyHandler = {
       return vProp.bind(value);
     }
     if (isPrimitive(vProp)) {
-      if (isArray(value) && p === "length") {
+      if (p === "length" && isArray(value)) {
         updateTracking(node, true);
         return vProp;
       }
@@ -1519,11 +1541,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);
   }
@@ -1538,6 +1566,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;
@@ -1551,7 +1581,7 @@ function assign(node, value) {
   return proxy2;
 }
 function deleteFn(node, key) {
-  if (key === void 0 && isChildNodeValue(node)) {
+  if (key === void 0 && isChildNode(node)) {
     key = node.key;
     node = node.parent;
   }
@@ -1571,7 +1601,8 @@ function deleteFn(node, key) {
 function handlerMapSet(node, p, value) {
   const vProp = value == null ? void 0 : value[p];
   if (p === "size") {
-    return getProxy(node, p);
+    updateTracking(node, true);
+    return value[p];
   } else if (isFunction(vProp)) {
     return function(a, b, c) {
       const l = arguments.length;
@@ -1582,23 +1613,16 @@ function handlerMapSet(node, p, value) {
         }
       } else if (p === "set") {
         if (l === 2) {
-          const prev = valueMap.get(a);
-          const ret = valueMap.set(a, b);
-          if (prev !== b) {
-            updateNodesAndNotify(getChildNode(node, a), b, prev);
-          }
-          return ret;
+          set(getChildNode(node, a), b);
         } else if (l === 1 && isMap(value)) {
           set(node, a);
         }
+        return getProxy(node);
       } else if (p === "delete") {
         if (l > 0) {
           const prev = value.get ? valueMap.get(a) : a;
-          const ret = value.delete(a);
-          if (ret) {
-            updateNodesAndNotify(getChildNode(node, a), void 0, prev);
-          }
-          return ret;
+          deleteFn(node, a);
+          return prev !== void 0;
         }
       } else if (p === "clear") {
         const prev = new Map(valueMap);
@@ -1614,7 +1638,7 @@ function handlerMapSet(node, p, value) {
         if (!value.has(p)) {
           notify(node, ret, prev, 0);
         }
-        return ret;
+        return getProxy(node);
       }
       const fn = observableFns.get(p);
       if (fn) {
@@ -1634,20 +1658,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);
     }
@@ -1664,6 +1688,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(
       {
@@ -1675,11 +1700,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);
   });
@@ -1696,6 +1724,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") {
@@ -1728,7 +1757,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) {
@@ -1743,10 +1774,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);
@@ -1835,7 +1868,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;
@@ -1844,14 +1879,15 @@ function activateNodeFunction(node, lazyFn) {
       }
       let value = activateFn();
       let didSetToObs = false;
-      if (isObservable(value)) {
-        didSetToObs = true;
+      const isObs = isObservable(value);
+      if (isObs || node.linkedToNode) {
+        didSetToObs = isObs;
         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;
+      const activated = !isObs ? value == null ? void 0 : value[symbolLinked] : void 0;
       if (activated) {
         node.activationState = activated;
         value = void 0;
@@ -1906,16 +1942,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 });
             }
           }
         }
@@ -1956,14 +1990,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;
@@ -1983,8 +2017,8 @@ function activateNodeBase(node, value) {
             setFn({
               value: value2,
               changes,
-              loading,
-              remote,
+              isFromPersist,
+              isFromSync,
               getPrevious
             });
             node.isComputing = false;
@@ -2019,26 +2053,31 @@ function activateNodeBase(node, value) {
 }
 function setToObservable(node, value) {
   var _a;
-  const linkedNode = getNode(value);
+  const linkedNode = value ? getNode(value) : void 0;
   if (linkedNode !== node && (linkedNode == null ? void 0 : linkedNode.linkedToNode) !== node) {
     node.linkedToNode = linkedNode;
-    linkedNode.linkedFromNodes || (linkedNode.linkedFromNodes = /* @__PURE__ */ new Set());
-    linkedNode.linkedFromNodes.add(node);
     (_a = node.linkedToNodeDispose) == null ? void 0 : _a.call(node);
-    node.linkedToNodeDispose = onChange(
-      linkedNode,
-      () => {
-        value = peekInternal(linkedNode);
-        set(node, value);
-      },
-      { initial: true },
-      /* @__PURE__ */ new Set([node])
-    );
+    if (linkedNode) {
+      linkedNode.linkedFromNodes || (linkedNode.linkedFromNodes = /* @__PURE__ */ new Set());
+      linkedNode.linkedFromNodes.add(node);
+      node.linkedToNodeDispose = onChange(
+        linkedNode,
+        () => {
+          value = peekInternal(linkedNode);
+          if (!isFunction(value)) {
+            set(node, value);
+          }
+        },
+        { initial: true },
+        /* @__PURE__ */ new Set([node])
+      );
+    }
   }
   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;
@@ -2056,27 +2095,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();
+        }
       }
     }
   }
@@ -2132,16 +2173,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) {
@@ -2150,45 +2181,6 @@ function computed(get2, set2) {
   );
 }
 
-// src/config.ts
-function configureLegendState({
-  observableFunctions,
-  observableProperties: observableProperties2,
-  jsonReplacer,
-  jsonReviver
-}) {
-  if (observableFunctions) {
-    for (const key in observableFunctions) {
-      const fn = observableFunctions[key];
-      observableFns.set(key, fn);
-      ObservablePrimitiveClass.prototype[key] = function(...args) {
-        return fn.call(this, this._node, ...args);
-      };
-    }
-  }
-  if (observableProperties2) {
-    for (const key in observableProperties2) {
-      const fns2 = observableProperties2[key];
-      observableProperties.set(key, fns2);
-      Object.defineProperty(ObservablePrimitiveClass.prototype, key, {
-        configurable: true,
-        get() {
-          return fns2.get.call(this, this._node);
-        },
-        set(value) {
-          return fns2.set.call(this, this._node, value);
-        }
-      });
-    }
-  }
-  if (jsonReplacer) {
-    globalState.replacer = jsonReplacer;
-  }
-  if (jsonReviver) {
-    globalState.reviver = jsonReviver;
-  }
-}
-
 // src/event.ts
 function event() {
   const obs = observable(0);
@@ -2219,66 +2211,33 @@ function proxy(get2, set2) {
   );
 }
 
-// src/retry.ts
-function calculateRetryDelay(retryOptions, attemptNum) {
-  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);
-    return delayTime;
-  }
-  return null;
-}
-function createRetryTimeout(retryOptions, attemptNum, fn) {
-  const delayTime = calculateRetryDelay(retryOptions, attemptNum);
-  if (delayTime) {
-    return setTimeout(fn, delayTime);
-  }
-}
-function runWithRetry(node, state, fn) {
-  const { waitFor } = node.activationState;
-  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);
-  }
-  if (isPromise(value) && retry) {
-    let timeoutRetry;
-    return new Promise((resolve) => {
-      const run = () => {
-        value.then((val) => {
-          node.activationState.persistedRetry = false;
-          resolve(val);
-        }).catch(() => {
-          state.attemptNum++;
-          if (timeoutRetry) {
-            clearTimeout(timeoutRetry);
-          }
-          if (!e.cancel) {
-            timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
-              value = fn(e);
-              run();
-            });
-          }
-        }).finally(() => {
-          node.activationState.persistedRetry = false;
-        });
-      };
-      run();
+// 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,
+      reset: () => Promise.resolve(),
+      sync: () => Promise.resolve(),
+      getPendingChanges: () => ({})
     });
   }
-  return value;
+  return node.state;
 }
 
 // index.ts
 var internal = {
   createPreviousHandler,
   clone,
+  deepMerge,
   ensureNodeValue,
   findIDKey,
   get,
@@ -2292,7 +2251,6 @@ var internal = {
   observableFns,
   optimized,
   peek,
-  runWithRetry,
   safeParse,
   safeStringify,
   set,
@@ -2311,7 +2269,6 @@ exports.beginBatch = beginBatch;
 exports.beginTracking = beginTracking;
 exports.computeSelector = computeSelector;
 exports.computed = computed;
-exports.configureLegendState = configureLegendState;
 exports.constructObjectWithPath = constructObjectWithPath;
 exports.deconstructObjectWithPath = deconstructObjectWithPath;
 exports.endBatch = endBatch;
@@ -2348,7 +2305,6 @@ exports.opaqueObject = opaqueObject;
 exports.optimized = optimized;
 exports.proxy = proxy;
 exports.setAtPath = setAtPath;
-exports.setInObservableAtPath = setInObservableAtPath;
 exports.setSilently = setSilently;
 exports.setupTracking = setupTracking;
 exports.shouldIgnoreUnobserved = shouldIgnoreUnobserved;