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

package/index.js

@@ -181,7 +181,7 @@ function setNodeValue(node, newValue) {
       parentNode.isSetting--;
     }
   }
-  return { prevValue, newValue };
+  return { prevValue, newValue, parentValue };
 }
 var arrNodeKeys = [];
 function getNodeValue(node) {
@@ -257,6 +257,9 @@ function extractFunction(node, key, fnOrComputed) {
 function equals(a, b) {
   return a === b || isDate(a) && isDate(b) && +a === +b;
 }
+function getKeys(obj, isArr, isMap2, isSet2) {
+  return isArr ? void 0 : obj ? isSet2 ? Array.from(obj) : isMap2 ? Array.from(obj.keys()) : Object.keys(obj) : [];
+}
 
 // src/ObservableHint.ts
 function addSymbol(value, symbol) {
@@ -276,16 +279,19 @@ var ObservableHint = {
   },
   plain: function plainObject(value) {
     return addSymbol(value, symbolPlain);
+  },
+  function: function plainObject2(value) {
+    return addSymbol(value, symbolPlain);
   }
 };
 
 // src/helpers.ts
-function computeSelector(selector, e, retainObservable) {
+function computeSelector(selector, getOptions, e, retainObservable) {
   let c = selector;
   if (!isObservable(c) && isFunction(c)) {
     c = e ? c(e) : c();
   }
-  return isObservable(c) && !retainObservable ? c.get() : c;
+  return isObservable(c) && !retainObservable ? c.get(getOptions) : c;
 }
 function getObservableIndex(value$) {
   const node = getNode(value$);
@@ -384,7 +390,7 @@ function _mergeIntoObservable(target, source, levelsDeep) {
   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) {
+  } else if (isTargetObj && isObject(source) || 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];
@@ -590,6 +596,7 @@ function computeChangesAtNode(changesInBatch, node, isFromPersist, isFromSync, v
       if (!isArraySubset(changes[0].path, change.path)) {
         changes.push(change);
         changeInBatch.level = Math.min(changeInBatch.level, level);
+        changeInBatch.whenOptimizedOnlyIf || (changeInBatch.whenOptimizedOnlyIf = whenOptimizedOnlyIf);
       }
     } else {
       changesInBatch.set(node, {
@@ -811,6 +818,109 @@ function linked(params, options) {
   return ret;
 }
 
+// src/middleware.ts
+var nodeMiddlewareHandlers = /* @__PURE__ */ new WeakMap();
+var queuedNodes = [];
+var queuedListeners = [];
+var queuedTypes = [];
+var queueSize = 0;
+var isMicrotaskScheduled = false;
+function registerMiddleware(node, type, handler) {
+  let handlersMap = nodeMiddlewareHandlers.get(node);
+  if (!handlersMap) {
+    handlersMap = /* @__PURE__ */ new Map();
+    nodeMiddlewareHandlers.set(node, handlersMap);
+  }
+  let handlers = handlersMap.get(type);
+  if (!handlers) {
+    handlers = /* @__PURE__ */ new Set();
+    handlersMap.set(type, handlers);
+  }
+  handlers.add(handler);
+  return () => {
+    const handlersMap2 = nodeMiddlewareHandlers.get(node);
+    if (!handlersMap2)
+      return;
+    const handlers2 = handlersMap2.get(type);
+    if (!handlers2)
+      return;
+    handlers2.delete(handler);
+    if (handlers2.size === 0) {
+      handlersMap2.delete(type);
+      if (handlersMap2.size === 0) {
+        nodeMiddlewareHandlers.delete(node);
+      }
+    }
+  };
+}
+function dispatchMiddlewareEvent(node, listener, type) {
+  const handlersMap = nodeMiddlewareHandlers.get(node);
+  if (!handlersMap || !handlersMap.has(type)) {
+    return;
+  }
+  const handlers = handlersMap.get(type);
+  if (!handlers || handlers.size === 0) {
+    return;
+  }
+  queuedNodes[queueSize] = node;
+  queuedListeners[queueSize] = listener;
+  queuedTypes[queueSize] = type;
+  queueSize++;
+  if (!isMicrotaskScheduled) {
+    isMicrotaskScheduled = true;
+    queueMicrotask(processQueuedEvents);
+  }
+}
+var eventObj = {
+  type: "listener-added",
+  node: null,
+  listener: void 0,
+  timestamp: 0
+};
+function processQueuedEvents() {
+  isMicrotaskScheduled = false;
+  const timestamp = typeof performance !== "undefined" ? performance.now() : Date.now();
+  eventObj.timestamp = timestamp;
+  for (let i = 0; i < queueSize; i++) {
+    const node = queuedNodes[i];
+    const listener = queuedListeners[i];
+    const type = queuedTypes[i];
+    const handlersMap = nodeMiddlewareHandlers.get(node);
+    if (!handlersMap)
+      continue;
+    const handlers = handlersMap.get(type);
+    if (!handlers || handlers.size === 0)
+      continue;
+    const nodeListeners = node.listeners;
+    const nodeListenersImmediate = node.listenersImmediate;
+    if (!nodeListeners && !nodeListenersImmediate) {
+      continue;
+    }
+    let isValid = false;
+    if (type === "listener-added") {
+      isValid = !!(nodeListeners == null ? void 0 : nodeListeners.has(listener)) || !!(nodeListenersImmediate == null ? void 0 : nodeListenersImmediate.has(listener));
+    } else if (type === "listener-removed") {
+      isValid = !(nodeListeners == null ? void 0 : nodeListeners.has(listener)) && !(nodeListenersImmediate == null ? void 0 : nodeListenersImmediate.has(listener));
+    } else {
+      isValid = !(nodeListeners == null ? void 0 : nodeListeners.size) && !(nodeListenersImmediate == null ? void 0 : nodeListenersImmediate.size);
+    }
+    if (isValid) {
+      eventObj.type = type;
+      eventObj.node = node;
+      eventObj.listener = listener;
+      const iterableHandlers = Array.from(handlers);
+      for (let j = 0; j < iterableHandlers.length; j++) {
+        try {
+          iterableHandlers[j](eventObj);
+        } catch (error) {
+          console.error(`Error in middleware handler for ${type}:`, error);
+        }
+      }
+    }
+  }
+  queueSize = 0;
+}
+
 // src/onChange.ts
 function onChange(node, callback, options = {}, fromLinks) {
   var _a;
@@ -881,6 +991,7 @@ function onChange(node, callback, options = {}, fromLinks) {
     pathParent = [parent.key, ...pathParent];
     parent = parent.parent;
   }
+  dispatchMiddlewareEvent(node, listener, "listener-added");
   return () => {
     listeners.delete(listener);
     extraDisposes == null ? void 0 : extraDisposes.forEach((fn) => fn());
@@ -889,6 +1000,10 @@ function onChange(node, callback, options = {}, fromLinks) {
       parent2.numListenersRecursive--;
       parent2 = parent2.parent;
     }
+    dispatchMiddlewareEvent(node, listener, "listener-removed");
+    if (listeners.size === 0) {
+      dispatchMiddlewareEvent(node, void 0, "listeners-cleared");
+    }
   };
 }
 function createCb(linkedFromNode, path, callback) {
@@ -969,13 +1084,13 @@ function updateTracking(node, track) {
 }
 
 // src/trackSelector.ts
-function trackSelector(selector, update, observeEvent, observeOptions, createResubscribe) {
+function trackSelector(selector, update, getOptions, observeEvent, observeOptions, createResubscribe) {
   var _a;
   let dispose;
   let resubscribe;
   let updateFn = update;
   beginTracking();
-  const value = selector ? computeSelector(selector, observeEvent, observeOptions == null ? void 0 : observeOptions.fromComputed) : selector;
+  const value = selector ? computeSelector(selector, getOptions, observeEvent, observeOptions == null ? void 0 : observeOptions.fromComputed) : selector;
   const tracker = tracking.current;
   const nodes = tracker.nodes;
   endTracking();
@@ -1023,7 +1138,11 @@ function observe(selectorOrRun, reactionOrOptions, options) {
     beginBatch();
     delete e.value;
     dispose == null ? void 0 : dispose();
-    const { dispose: _dispose, value, nodes } = trackSelector(selectorOrRun, update, e, options);
+    const {
+      dispose: _dispose,
+      value,
+      nodes
+    } = trackSelector(selectorOrRun, update, void 0, e, options);
     dispose = _dispose;
     e.value = value;
     e.nodes = nodes;
@@ -1068,10 +1187,13 @@ function _when(predicate, effect, checkReady) {
       let isOk = true;
       if (isArray(ret)) {
         for (let i = 0; i < ret.length; i++) {
-          if (isObservable(ret[i])) {
-            ret[i] = computeSelector(ret[i]);
+          let item = ret[i];
+          if (isObservable(item)) {
+            item = computeSelector(item);
+          } else if (isFunction(item)) {
+            item = item();
           }
-          isOk = isOk && !!(checkReady ? isObservableValueReady(ret[i]) : ret[i]);
+          isOk = isOk && !!(checkReady ? isObservableValueReady(item) : item);
         }
       } else {
         isOk = checkReady ? isObservableValueReady(ret) : ret;
@@ -1170,9 +1292,6 @@ function collectionSetter(node, target, prop, ...args) {
     return ret;
   }
 }
-function getKeys(obj, isArr, isMap2) {
-  return isArr ? void 0 : obj ? isMap2 ? Array.from(obj.keys()) : Object.keys(obj) : [];
-}
 function updateNodes(parent, obj, prevValue) {
   var _a, _b, _c;
   if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined" && isObject(obj)) {
@@ -1201,9 +1320,11 @@ function updateNodes(parent, obj, prevValue) {
   let prevChildrenById;
   let moved;
   const isCurMap = isMap(obj);
+  const isCurSet = isSet(obj);
   const isPrevMap = isMap(prevValue);
-  const keys = getKeys(obj, isArr, isCurMap);
-  const keysPrev = getKeys(prevValue, isArr, isPrevMap);
+  const isPrevSet = isSet(prevValue);
+  const keys = getKeys(obj, isArr, isCurMap, isCurSet);
+  const keysPrev = getKeys(prevValue, isArr, isPrevMap, isPrevSet);
   const length = ((_a = keys || obj) == null ? void 0 : _a.length) || 0;
   const lengthPrev = ((_b = keysPrev || prevValue) == null ? void 0 : _b.length) || 0;
   let idField;
@@ -1553,7 +1674,9 @@ var proxyHandler = {
     if (isObservable(thisArg)) {
       thisArg = thisArg.peek();
     }
-    return Reflect.apply(target.lazyFn || target, thisArg, argArray);
+    const fnRaw = getNodeValue(target);
+    const fn = isFunction(fnRaw) ? fnRaw : target.lazyFn || target;
+    return Reflect.apply(fn, thisArg, argArray);
   }
 };
 function set(node, newValue) {
@@ -1585,8 +1708,8 @@ function setKey(node, key, newValue, level) {
   if (isObservable(newValue)) {
     setToObservable(childNode, newValue);
   } else {
-    const { newValue: savedValue, prevValue } = setNodeValue(childNode, newValue);
-    const isPrim = isPrimitive(savedValue) || savedValue instanceof Date;
+    const { newValue: savedValue, prevValue, parentValue } = setNodeValue(childNode, newValue);
+    const isPrim = isPrimitive(prevValue) || prevValue instanceof Date || isPrimitive(savedValue) || savedValue instanceof Date;
     if (!isPrim) {
       let parent = childNode;
       do {
@@ -1597,7 +1720,17 @@ function setKey(node, key, newValue, level) {
     const notify2 = !equals(savedValue, prevValue);
     const forceNotify = !notify2 && childNode.isComputing && !isPrim;
     if (notify2 || forceNotify) {
-      updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level, forceNotify);
+      updateNodesAndNotify(
+        node,
+        savedValue,
+        prevValue,
+        childNode,
+        parentValue,
+        isPrim,
+        isRoot,
+        level,
+        forceNotify
+      );
     }
     extractFunctionOrComputed(node, key, savedValue);
   }
@@ -1652,7 +1785,7 @@ function handlerMapSet(node, p, value) {
   } else if (isFunction(vProp)) {
     return function(a, b, c) {
       const l = arguments.length;
-      const valueMap = value;
+      const valueMapOrSet = value;
       if (p === "get") {
         if (l > 0 && typeof a !== "boolean" && a !== optimized) {
           return getProxy(node, a);
@@ -1666,14 +1799,14 @@ function handlerMapSet(node, p, value) {
         return getProxy(node);
       } else if (p === "delete") {
         if (l > 0) {
-          const prev = value.get ? valueMap.get(a) : a;
+          const prev = value.get ? valueMapOrSet.get(a) : a;
           deleteFn(node, a);
           return prev !== void 0;
         }
       } else if (p === "clear") {
-        const prev = new Map(valueMap);
-        const size = valueMap.size;
-        valueMap.clear();
+        const prev = isSet(valueMapOrSet) ? new Set(valueMapOrSet) : new Map(valueMapOrSet);
+        const size = valueMapOrSet.size;
+        valueMapOrSet.clear();
         if (size) {
           updateNodesAndNotify(node, value, prev);
         }
@@ -1704,7 +1837,7 @@ function handlerMapSet(node, p, value) {
     };
   }
 }
-function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRoot, level, forceNotify) {
+function updateNodesAndNotify(node, newValue, prevValue, childNode, parentValue, isPrim, isRoot, level, forceNotify) {
   if (!childNode)
     childNode = node;
   beginBatch();
@@ -1713,15 +1846,29 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
   }
   let hasADiff = forceNotify || isPrim;
   let whenOptimizedOnlyIf = false;
+  let valueAsArr;
+  let valueAsMap;
   if (!isPrim || prevValue && !isPrimitive(prevValue)) {
     if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined") {
       __devUpdateNodes.clear();
     }
     hasADiff = hasADiff || updateNodes(childNode, newValue, prevValue);
     if (isArray(newValue)) {
-      whenOptimizedOnlyIf = (newValue == null ? void 0 : newValue.length) !== (prevValue == null ? void 0 : prevValue.length);
+      valueAsArr = newValue;
+    } else if (isMap(newValue) || isSet(newValue)) {
+      valueAsMap = newValue;
     }
   }
+  if (isArray(parentValue)) {
+    valueAsArr = parentValue;
+  } else if (isMap(parentValue) || isSet(parentValue)) {
+    valueAsMap = parentValue;
+  }
+  if (valueAsArr) {
+    whenOptimizedOnlyIf = (valueAsArr == null ? void 0 : valueAsArr.length) !== (prevValue == null ? void 0 : prevValue.length);
+  } else if (valueAsMap) {
+    whenOptimizedOnlyIf = (valueAsMap == null ? void 0 : valueAsMap.size) !== (prevValue == null ? void 0 : prevValue.size);
+  }
   if (isPrim || !newValue || isEmpty(newValue) && !isEmpty(prevValue) ? newValue !== prevValue : hasADiff) {
     notify(
       isPrim && isRoot ? node : childNode,
@@ -1788,7 +1935,7 @@ function peek(node) {
 }
 var isFlushing = false;
 function peekInternal(node, activateRecursive) {
-  var _a;
+  var _a, _b;
   isFlushing = true;
   if (activateRecursive && ((_a = node.dirtyChildren) == null ? void 0 : _a.size)) {
     const dirty = Array.from(node.dirtyChildren);
@@ -1803,7 +1950,10 @@ function peekInternal(node, activateRecursive) {
   }
   isFlushing = false;
   let value = getNodeValue(node);
-  if (!globalState.isLoadingLocal) {
+  if (((_b = node.parent) == null ? void 0 : _b.isPlain) || isHintPlain(value)) {
+    node.isPlain = true;
+  }
+  if (!node.root.isLoadingLocal && !node.isPlain) {
     value = checkLazy(node, value, !!activateRecursive);
   }
   return value;
@@ -1963,6 +2113,9 @@ function activateNodeFunction(node, lazyFn) {
           value = (_d = (_c = activated2.get) == null ? void 0 : _c.call(activated2)) != null ? _d : activated2.initial;
         }
       }
+      if (ignoreThisUpdate) {
+        activatedValue = value;
+      }
       wasPromise = wasPromise || isPromise(value);
       return value;
     },
@@ -2274,7 +2427,14 @@ function syncState(obs) {
         syncCount: 0,
         resetPersistence: void 0,
         reset: () => Promise.resolve(),
-        sync: () => Promise.resolve(),
+        sync: () => {
+          var _a;
+          obs.peek();
+          if ((_a = node.state) == null ? void 0 : _a.isGetting.peek()) {
+            return when(node.state.isLoaded);
+          }
+          return Promise.resolve();
+        },
         getPendingChanges: () => ({}),
         // TODOV3 remove
         clearPersist: void 0
@@ -2292,6 +2452,7 @@ var internal = {
   ensureNodeValue,
   findIDKey,
   get,
+  getKeys,
   getNode,
   getNodeValue,
   getPathType,
@@ -2304,6 +2465,7 @@ var internal = {
   observableFns,
   optimized,
   peek,
+  registerMiddleware,
   safeParse,
   safeStringify,
   set,