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

package/index.d.mts

@@ -391,6 +391,23 @@ interface ObservablePrimitiveState {
 }
 declare function ObservablePrimitiveClass<T>(this: ObservablePrimitive<T> & ObservablePrimitiveState, node: NodeInfo): void;
 
+type MiddlewareEventType = 'listener-added' | 'listener-removed' | 'listeners-cleared';
+interface MiddlewareEvent {
+    type: MiddlewareEventType;
+    node: NodeInfo;
+    listener?: NodeListener;
+    timestamp: number;
+}
+type MiddlewareHandler = (event: MiddlewareEvent) => void;
+/**
+ * Register a middleware handler for a specific node and event type
+ * @param node The node to register the middleware handler for
+ * @param type The event type to handle
+ * @param handler The middleware handler function
+ * @returns A function to remove the handler
+ */
+declare function registerMiddleware(node: NodeInfo, type: MiddlewareEventType, handler: MiddlewareHandler): () => void;
+
 declare const internal: {
     createPreviousHandler: typeof createPreviousHandler;
     clone: typeof clone;
@@ -425,6 +442,7 @@ declare const internal: {
     observableFns: Map<string, (node: NodeInfo, ...args: any[]) => any>;
     optimized: symbol;
     peek: typeof peek;
+    registerMiddleware: typeof registerMiddleware;
     safeParse: typeof safeParse;
     safeStringify: typeof safeStringify;
     set: typeof set;

package/index.d.ts

@@ -391,6 +391,23 @@ interface ObservablePrimitiveState {
 }
 declare function ObservablePrimitiveClass<T>(this: ObservablePrimitive<T> & ObservablePrimitiveState, node: NodeInfo): void;
 
+type MiddlewareEventType = 'listener-added' | 'listener-removed' | 'listeners-cleared';
+interface MiddlewareEvent {
+    type: MiddlewareEventType;
+    node: NodeInfo;
+    listener?: NodeListener;
+    timestamp: number;
+}
+type MiddlewareHandler = (event: MiddlewareEvent) => void;
+/**
+ * Register a middleware handler for a specific node and event type
+ * @param node The node to register the middleware handler for
+ * @param type The event type to handle
+ * @param handler The middleware handler function
+ * @returns A function to remove the handler
+ */
+declare function registerMiddleware(node: NodeInfo, type: MiddlewareEventType, handler: MiddlewareHandler): () => void;
+
 declare const internal: {
     createPreviousHandler: typeof createPreviousHandler;
     clone: typeof clone;
@@ -425,6 +442,7 @@ declare const internal: {
     observableFns: Map<string, (node: NodeInfo, ...args: any[]) => any>;
     optimized: symbol;
     peek: typeof peek;
+    registerMiddleware: typeof registerMiddleware;
     safeParse: typeof safeParse;
     safeStringify: typeof safeStringify;
     set: typeof set;

package/index.js

@@ -818,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;
@@ -888,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());
@@ -896,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) {
@@ -2005,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;
     },
@@ -2354,6 +2465,7 @@ var internal = {
   observableFns,
   optimized,
   peek,
+  registerMiddleware,
   safeParse,
   safeStringify,
   set,

package/index.mjs

@@ -816,6 +816,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;
@@ -886,6 +989,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());
@@ -894,6 +998,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) {
@@ -2003,6 +2111,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;
     },
@@ -2352,6 +2463,7 @@ var internal = {
   observableFns,
   optimized,
   peek,
+  registerMiddleware,
   safeParse,
   safeStringify,
   set,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/state",
-  "version": "3.0.0-beta.29",
+  "version": "3.0.0-beta.30",
   "description": "legend-state",
   "sideEffects": false,
   "private": false,

package/sync.js

@@ -234,7 +234,17 @@ function createRevertChanges(obs$, changes) {
 }
 
 // src/sync/syncObservable.ts
-var { clone: clone2, deepMerge, getNode, getNodeValue, getValueAtPath, globalState, symbolLinked, createPreviousHandler } = state.internal;
+var {
+  clone: clone2,
+  createPreviousHandler,
+  deepMerge,
+  getNode,
+  getNodeValue,
+  getValueAtPath,
+  globalState,
+  registerMiddleware,
+  symbolLinked
+} = state.internal;
 var mapSyncPlugins = /* @__PURE__ */ new WeakMap();
 var allSyncStates = /* @__PURE__ */ new Map();
 var metadatas = /* @__PURE__ */ new WeakMap();
@@ -937,236 +947,237 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       }
       const lastSync = (_a = metadatas.get(obs$)) == null ? void 0 : _a.lastSync;
       const pending = localState.pendingChanges;
-      if (get || subscribe) {
-        const { waitFor } = syncOptions;
-        const runGet = () => {
-          var _a2;
-          const onChange = async ({ value, mode, lastSync: lastSync2 }) => {
-            mode = mode || syncOptions.mode || "set";
-            if (value !== void 0) {
-              value = transformLoadData(value, syncOptions, true, "get");
-              if (state.isPromise(value)) {
-                value = await value;
-              }
-              const pending2 = localState.pendingChanges;
-              const currentValue = obs$.peek();
-              if (pending2) {
-                let didChangeMetadata = false;
-                Object.keys(pending2).forEach((key) => {
-                  const p = key.split("/").filter((k) => k !== "");
-                  const { v, t } = pending2[key];
-                  if (t.length === 0 || !value) {
+      const { waitFor } = syncOptions;
+      const runGet = () => {
+        var _a2;
+        const onChange = async ({ value, mode, lastSync: lastSync2 }) => {
+          mode = mode || syncOptions.mode || "set";
+          if (value !== void 0) {
+            value = transformLoadData(value, syncOptions, true, "get");
+            if (state.isPromise(value)) {
+              value = await value;
+            }
+            const pending2 = localState.pendingChanges;
+            const currentValue = obs$.peek();
+            if (pending2) {
+              let didChangeMetadata = false;
+              Object.keys(pending2).forEach((key) => {
+                const p = key.split("/").filter((k) => k !== "");
+                const { v, t } = pending2[key];
+                if (t.length === 0 || !value) {
+                  const oldValue = clone2(value);
+                  pending2[key].p = key ? oldValue[key] : oldValue;
+                  if (state.isObject(value) && state.isObject(v)) {
+                    Object.assign(value, key ? { [key]: v } : v);
+                  } else if (!key) {
+                    value = v;
+                  }
+                } else if (value[p[0]] !== void 0) {
+                  const curValue = getValueAtPath(currentValue, p);
+                  const newValue = getValueAtPath(value, p);
+                  if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
+                    delete pending2[key];
+                    didChangeMetadata = true;
+                  } else {
                     const oldValue = clone2(value);
-                    pending2[key].p = key ? oldValue[key] : oldValue;
-                    if (state.isObject(value) && state.isObject(v)) {
-                      Object.assign(value, key ? { [key]: v } : v);
-                    } else if (!key) {
-                      value = v;
-                    }
-                  } else if (value[p[0]] !== void 0) {
-                    const curValue = getValueAtPath(currentValue, p);
-                    const newValue = getValueAtPath(value, p);
-                    if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
-                      delete pending2[key];
-                      didChangeMetadata = true;
-                    } else {
-                      const oldValue = clone2(value);
-                      pending2[key].p = getValueAtPath(oldValue, p);
-                      didChangeMetadata = true;
-                      value = state.setAtPath(
-                        value,
-                        p,
-                        t,
-                        v,
-                        "merge",
-                        obs$.peek(),
-                        (path, value2) => {
-                          delete pending2[key];
-                          pending2[path.join("/")] = {
-                            p: null,
-                            v: value2,
-                            t: t.slice(0, path.length)
-                          };
-                        }
-                      );
-                    }
+                    pending2[key].p = getValueAtPath(oldValue, p);
+                    didChangeMetadata = true;
+                    value = state.setAtPath(
+                      value,
+                      p,
+                      t,
+                      v,
+                      "merge",
+                      obs$.peek(),
+                      (path, value2) => {
+                        delete pending2[key];
+                        pending2[path.join("/")] = {
+                          p: null,
+                          v: value2,
+                          t: t.slice(0, path.length)
+                        };
+                      }
+                    );
                   }
-                });
-                if (didChangeMetadata && syncOptions.persist) {
-                  updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
-                    pending: pending2
-                  });
                 }
+              });
+              if (didChangeMetadata && syncOptions.persist) {
+                updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+                  pending: pending2
+                });
               }
-              onChangeRemote2(() => {
-                if (state.isPlainObject(value)) {
-                  value = state.ObservableHint.plain(value);
+            }
+            onChangeRemote2(() => {
+              if (state.isPlainObject(value)) {
+                value = state.ObservableHint.plain(value);
+              }
+              if (mode === "assign") {
+                obs$.assign(value);
+              } else if (mode === "append") {
+                if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !state.isArray(value)) {
+                  console.error("[legend-state] mode:append expects the value to be an array");
                 }
-                if (mode === "assign") {
-                  obs$.assign(value);
-                } else if (mode === "append") {
-                  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !state.isArray(value)) {
-                    console.error("[legend-state] mode:append expects the value to be an array");
-                  }
-                  obs$.push(...value);
-                } else if (mode === "prepend") {
-                  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !state.isArray(value)) {
-                    console.error("[legend-state] mode:prepend expects the value to be an array");
-                  }
-                  obs$.splice(0, 0, ...value);
-                } else if (mode === "merge") {
-                  state.mergeIntoObservable(obs$, value);
-                } else {
-                  obs$.set(value);
+                obs$.push(...value);
+              } else if (mode === "prepend") {
+                if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !state.isArray(value)) {
+                  console.error("[legend-state] mode:prepend expects the value to be an array");
                 }
-              });
-            }
-            if (lastSync2 && syncOptions.persist) {
-              updateMetadata(obs$, localState, syncState$, syncOptions, {
-                lastSync: lastSync2
-              });
-            }
-          };
-          if (node.activationState) {
-            node.activationState.onChange = onChange;
+                obs$.splice(0, 0, ...value);
+              } else if (mode === "merge") {
+                state.mergeIntoObservable(obs$, value);
+              } else {
+                obs$.set(value);
+              }
+            });
           }
-          if (!isSubscribed && syncOptions.subscribe) {
-            const subscribe2 = syncOptions.subscribe;
-            isSubscribed = true;
-            const doSubscribe = () => {
-              const subscribeParams = {
-                node,
-                value$: obs$,
-                lastSync,
-                update: (params) => {
-                  state.when(
-                    () => !get || syncState$.isLoaded.get(),
-                    () => {
-                      state.when(waitFor || true, () => {
-                        params.mode || (params.mode = syncOptions.mode || "merge");
-                        onChange(params);
-                        if (!syncState$.isLoaded.peek()) {
-                          syncState$.assign({
-                            isLoaded: syncStateValue.numPendingRemoteLoads < 1,
-                            error: void 0,
-                            isGetting: syncStateValue.numPendingGets > 0
-                          });
-                        }
-                      });
-                    }
-                  );
-                },
-                refresh: () => state.when(syncState$.isLoaded, sync),
-                onError: (error) => onGetError(error, {
-                  source: "subscribe",
-                  subscribeParams,
-                  type: "get",
-                  retry: {}
-                })
-              };
-              unsubscribe = subscribe2(subscribeParams);
-            };
-            if (waitFor) {
-              state.whenReady(waitFor, doSubscribe);
-            } else {
-              doSubscribe();
-            }
+          if (lastSync2 && syncOptions.persist) {
+            updateMetadata(obs$, localState, syncState$, syncOptions, {
+              lastSync: lastSync2
+            });
           }
-          const existingValue = getNodeValue(node);
-          if (get) {
-            const getParams = {
+        };
+        if (node.activationState) {
+          node.activationState.onChange = onChange;
+        }
+        if (!isSubscribed && syncOptions.subscribe) {
+          const subscribe2 = syncOptions.subscribe;
+          const doSubscribe = () => {
+            isSubscribed = true;
+            const subscribeParams = {
               node,
               value$: obs$,
-              value: state.isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
-              mode: syncOptions.mode,
-              refresh: sync,
-              options: syncOptions,
               lastSync,
-              updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
-              onError: onGetError,
-              retryNum: 0,
-              cancelRetry: false
-            };
-            let modeBeforeReset = void 0;
-            const beforeGetParams = {
-              value: getParams.value,
-              lastSync,
-              pendingChanges: pending && !state.isEmpty(pending) ? pending : void 0,
-              clearPendingChanges: async () => {
-                localState.pendingChanges = {};
-                await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
-                  pending: localState.pendingChanges
-                });
-              },
-              resetCache: () => {
-                var _a3;
-                modeBeforeReset = getParams.mode;
-                getParams.mode = "set";
-                return (_a3 = syncStateValue.resetPersistence) == null ? void 0 : _a3.call(syncStateValue);
+              update: (params) => {
+                state.when(
+                  () => !get || syncState$.isLoaded.get(),
+                  () => {
+                    state.when(waitFor || true, () => {
+                      params.mode || (params.mode = syncOptions.mode || "merge");
+                      onChange(params);
+                      if (!syncState$.isLoaded.peek()) {
+                        syncState$.assign({
+                          isLoaded: syncStateValue.numPendingRemoteLoads < 1,
+                          error: void 0,
+                          isGetting: syncStateValue.numPendingGets > 0
+                        });
+                      }
+                    });
+                  }
+                );
               },
-              cancel: false
+              refresh: () => state.when(syncState$.isLoaded, sync),
+              onError: (error) => onGetError(error, {
+                source: "subscribe",
+                subscribeParams,
+                type: "get",
+                retry: {}
+              })
             };
-            (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, beforeGetParams);
-            if (!beforeGetParams.cancel) {
-              syncState$.assign({
-                numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
-                isGetting: true
-              });
-              const got = runWithRetry(getParams, syncOptions.retry, node, (retryEvent) => {
-                const params = getParams;
-                params.cancelRetry = retryEvent.cancelRetry;
-                params.retryNum = retryEvent.retryNum;
-                return get(params);
+            unsubscribe = subscribe2(subscribeParams);
+            registerMiddleware(node, "listeners-cleared", () => {
+              if (unsubscribe) {
+                isSubscribed = false;
+                unsubscribe();
+                unsubscribe = void 0;
+              }
+            });
+            registerMiddleware(node, "listener-added", () => {
+              if (!isSubscribed) {
+                doSubscribe();
+              }
+            });
+          };
+          if (waitFor) {
+            state.whenReady(waitFor, doSubscribe);
+          } else {
+            doSubscribe();
+          }
+        }
+        const existingValue = getNodeValue(node);
+        if (get) {
+          const getParams = {
+            node,
+            value$: obs$,
+            value: state.isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
+            mode: syncOptions.mode,
+            refresh: sync,
+            options: syncOptions,
+            lastSync,
+            updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
+            onError: onGetError,
+            retryNum: 0,
+            cancelRetry: false
+          };
+          let modeBeforeReset = void 0;
+          const beforeGetParams = {
+            value: getParams.value,
+            lastSync,
+            pendingChanges: pending && !state.isEmpty(pending) ? pending : void 0,
+            clearPendingChanges: async () => {
+              localState.pendingChanges = {};
+              await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+                pending: localState.pendingChanges
               });
-              const numGets = node.numGets = (node.numGets || 0) + 1;
-              const handle = (value) => {
-                syncState$.numPendingGets.set((v) => v - 1);
-                if (isWaitingForLoad) {
-                  isWaitingForLoad = false;
-                  syncStateValue.numPendingRemoteLoads--;
-                }
-                if (numGets >= (node.getNumResolved || 0)) {
-                  node.getNumResolved = node.numGets;
-                  onChange({
-                    value,
-                    lastSync: getParams.lastSync,
-                    mode: getParams.mode
-                  });
-                }
-                if (modeBeforeReset) {
-                  getParams.mode = modeBeforeReset;
-                  modeBeforeReset = void 0;
-                }
-                syncState$.assign({
-                  isLoaded: syncStateValue.numPendingRemoteLoads < 1,
-                  error: void 0,
-                  isGetting: syncStateValue.numPendingGets > 0
-                });
-              };
-              if (state.isPromise(got)) {
-                got.then(handle).catch((error) => {
-                  onGetError(
-                    error,
-                    { getParams, source: "get", type: "get", retry: getParams },
-                    true
-                  );
+            },
+            resetCache: () => {
+              var _a3;
+              modeBeforeReset = getParams.mode;
+              getParams.mode = "set";
+              return (_a3 = syncStateValue.resetPersistence) == null ? void 0 : _a3.call(syncStateValue);
+            },
+            cancel: false
+          };
+          (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, beforeGetParams);
+          if (!beforeGetParams.cancel) {
+            syncState$.assign({
+              numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
+              isGetting: true
+            });
+            const got = runWithRetry(getParams, syncOptions.retry, node, (retryEvent) => {
+              const params = getParams;
+              params.cancelRetry = retryEvent.cancelRetry;
+              params.retryNum = retryEvent.retryNum;
+              return get(params);
+            });
+            const numGets = node.numGets = (node.numGets || 0) + 1;
+            const handle = (value) => {
+              syncState$.numPendingGets.set((v) => v - 1);
+              if (isWaitingForLoad) {
+                isWaitingForLoad = false;
+                syncStateValue.numPendingRemoteLoads--;
+              }
+              if (numGets >= (node.getNumResolved || 0)) {
+                node.getNumResolved = node.numGets;
+                onChange({
+                  value,
+                  lastSync: getParams.lastSync,
+                  mode: getParams.mode
                 });
-              } else {
-                handle(got);
               }
+              if (modeBeforeReset) {
+                getParams.mode = modeBeforeReset;
+                modeBeforeReset = void 0;
+              }
+              syncState$.assign({
+                isLoaded: syncStateValue.numPendingRemoteLoads < 1,
+                error: void 0,
+                isGetting: syncStateValue.numPendingGets > 0
+              });
+            };
+            if (state.isPromise(got)) {
+              got.then(handle).catch((error) => {
+                onGetError(error, { getParams, source: "get", type: "get", retry: getParams }, true);
+              });
+            } else {
+              handle(got);
             }
           }
-        };
-        if (waitFor) {
-          state.whenReady(waitFor, () => state.trackSelector(runGet, sync));
-        } else {
-          state.trackSelector(runGet, sync);
         }
+      };
+      if (waitFor) {
+        state.whenReady(waitFor, () => state.trackSelector(runGet, sync));
       } else {
-        syncState$.assign({
-          isLoaded: true,
-          error: void 0
-        });
+        state.trackSelector(runGet, sync);
       }
       if (!isSynced) {
         isSynced = true;

package/sync.mjs

@@ -232,7 +232,17 @@ function createRevertChanges(obs$, changes) {
 }
 
 // src/sync/syncObservable.ts
-var { clone: clone2, deepMerge, getNode, getNodeValue, getValueAtPath, globalState, symbolLinked, createPreviousHandler } = internal;
+var {
+  clone: clone2,
+  createPreviousHandler,
+  deepMerge,
+  getNode,
+  getNodeValue,
+  getValueAtPath,
+  globalState,
+  registerMiddleware,
+  symbolLinked
+} = internal;
 var mapSyncPlugins = /* @__PURE__ */ new WeakMap();
 var allSyncStates = /* @__PURE__ */ new Map();
 var metadatas = /* @__PURE__ */ new WeakMap();
@@ -935,236 +945,237 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       }
       const lastSync = (_a = metadatas.get(obs$)) == null ? void 0 : _a.lastSync;
       const pending = localState.pendingChanges;
-      if (get || subscribe) {
-        const { waitFor } = syncOptions;
-        const runGet = () => {
-          var _a2;
-          const onChange = async ({ value, mode, lastSync: lastSync2 }) => {
-            mode = mode || syncOptions.mode || "set";
-            if (value !== void 0) {
-              value = transformLoadData(value, syncOptions, true, "get");
-              if (isPromise$1(value)) {
-                value = await value;
-              }
-              const pending2 = localState.pendingChanges;
-              const currentValue = obs$.peek();
-              if (pending2) {
-                let didChangeMetadata = false;
-                Object.keys(pending2).forEach((key) => {
-                  const p = key.split("/").filter((k) => k !== "");
-                  const { v, t } = pending2[key];
-                  if (t.length === 0 || !value) {
+      const { waitFor } = syncOptions;
+      const runGet = () => {
+        var _a2;
+        const onChange = async ({ value, mode, lastSync: lastSync2 }) => {
+          mode = mode || syncOptions.mode || "set";
+          if (value !== void 0) {
+            value = transformLoadData(value, syncOptions, true, "get");
+            if (isPromise$1(value)) {
+              value = await value;
+            }
+            const pending2 = localState.pendingChanges;
+            const currentValue = obs$.peek();
+            if (pending2) {
+              let didChangeMetadata = false;
+              Object.keys(pending2).forEach((key) => {
+                const p = key.split("/").filter((k) => k !== "");
+                const { v, t } = pending2[key];
+                if (t.length === 0 || !value) {
+                  const oldValue = clone2(value);
+                  pending2[key].p = key ? oldValue[key] : oldValue;
+                  if (isObject(value) && isObject(v)) {
+                    Object.assign(value, key ? { [key]: v } : v);
+                  } else if (!key) {
+                    value = v;
+                  }
+                } else if (value[p[0]] !== void 0) {
+                  const curValue = getValueAtPath(currentValue, p);
+                  const newValue = getValueAtPath(value, p);
+                  if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
+                    delete pending2[key];
+                    didChangeMetadata = true;
+                  } else {
                     const oldValue = clone2(value);
-                    pending2[key].p = key ? oldValue[key] : oldValue;
-                    if (isObject(value) && isObject(v)) {
-                      Object.assign(value, key ? { [key]: v } : v);
-                    } else if (!key) {
-                      value = v;
-                    }
-                  } else if (value[p[0]] !== void 0) {
-                    const curValue = getValueAtPath(currentValue, p);
-                    const newValue = getValueAtPath(value, p);
-                    if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
-                      delete pending2[key];
-                      didChangeMetadata = true;
-                    } else {
-                      const oldValue = clone2(value);
-                      pending2[key].p = getValueAtPath(oldValue, p);
-                      didChangeMetadata = true;
-                      value = setAtPath(
-                        value,
-                        p,
-                        t,
-                        v,
-                        "merge",
-                        obs$.peek(),
-                        (path, value2) => {
-                          delete pending2[key];
-                          pending2[path.join("/")] = {
-                            p: null,
-                            v: value2,
-                            t: t.slice(0, path.length)
-                          };
-                        }
-                      );
-                    }
+                    pending2[key].p = getValueAtPath(oldValue, p);
+                    didChangeMetadata = true;
+                    value = setAtPath(
+                      value,
+                      p,
+                      t,
+                      v,
+                      "merge",
+                      obs$.peek(),
+                      (path, value2) => {
+                        delete pending2[key];
+                        pending2[path.join("/")] = {
+                          p: null,
+                          v: value2,
+                          t: t.slice(0, path.length)
+                        };
+                      }
+                    );
                   }
-                });
-                if (didChangeMetadata && syncOptions.persist) {
-                  updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
-                    pending: pending2
-                  });
                 }
+              });
+              if (didChangeMetadata && syncOptions.persist) {
+                updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+                  pending: pending2
+                });
               }
-              onChangeRemote2(() => {
-                if (isPlainObject(value)) {
-                  value = ObservableHint.plain(value);
+            }
+            onChangeRemote2(() => {
+              if (isPlainObject(value)) {
+                value = ObservableHint.plain(value);
+              }
+              if (mode === "assign") {
+                obs$.assign(value);
+              } else if (mode === "append") {
+                if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !isArray(value)) {
+                  console.error("[legend-state] mode:append expects the value to be an array");
                 }
-                if (mode === "assign") {
-                  obs$.assign(value);
-                } else if (mode === "append") {
-                  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !isArray(value)) {
-                    console.error("[legend-state] mode:append expects the value to be an array");
-                  }
-                  obs$.push(...value);
-                } else if (mode === "prepend") {
-                  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !isArray(value)) {
-                    console.error("[legend-state] mode:prepend expects the value to be an array");
-                  }
-                  obs$.splice(0, 0, ...value);
-                } else if (mode === "merge") {
-                  mergeIntoObservable(obs$, value);
-                } else {
-                  obs$.set(value);
+                obs$.push(...value);
+              } else if (mode === "prepend") {
+                if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !isArray(value)) {
+                  console.error("[legend-state] mode:prepend expects the value to be an array");
                 }
-              });
-            }
-            if (lastSync2 && syncOptions.persist) {
-              updateMetadata(obs$, localState, syncState$, syncOptions, {
-                lastSync: lastSync2
-              });
-            }
-          };
-          if (node.activationState) {
-            node.activationState.onChange = onChange;
+                obs$.splice(0, 0, ...value);
+              } else if (mode === "merge") {
+                mergeIntoObservable(obs$, value);
+              } else {
+                obs$.set(value);
+              }
+            });
           }
-          if (!isSubscribed && syncOptions.subscribe) {
-            const subscribe2 = syncOptions.subscribe;
-            isSubscribed = true;
-            const doSubscribe = () => {
-              const subscribeParams = {
-                node,
-                value$: obs$,
-                lastSync,
-                update: (params) => {
-                  when(
-                    () => !get || syncState$.isLoaded.get(),
-                    () => {
-                      when(waitFor || true, () => {
-                        params.mode || (params.mode = syncOptions.mode || "merge");
-                        onChange(params);
-                        if (!syncState$.isLoaded.peek()) {
-                          syncState$.assign({
-                            isLoaded: syncStateValue.numPendingRemoteLoads < 1,
-                            error: void 0,
-                            isGetting: syncStateValue.numPendingGets > 0
-                          });
-                        }
-                      });
-                    }
-                  );
-                },
-                refresh: () => when(syncState$.isLoaded, sync),
-                onError: (error) => onGetError(error, {
-                  source: "subscribe",
-                  subscribeParams,
-                  type: "get",
-                  retry: {}
-                })
-              };
-              unsubscribe = subscribe2(subscribeParams);
-            };
-            if (waitFor) {
-              whenReady(waitFor, doSubscribe);
-            } else {
-              doSubscribe();
-            }
+          if (lastSync2 && syncOptions.persist) {
+            updateMetadata(obs$, localState, syncState$, syncOptions, {
+              lastSync: lastSync2
+            });
           }
-          const existingValue = getNodeValue(node);
-          if (get) {
-            const getParams = {
+        };
+        if (node.activationState) {
+          node.activationState.onChange = onChange;
+        }
+        if (!isSubscribed && syncOptions.subscribe) {
+          const subscribe2 = syncOptions.subscribe;
+          const doSubscribe = () => {
+            isSubscribed = true;
+            const subscribeParams = {
               node,
               value$: obs$,
-              value: isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
-              mode: syncOptions.mode,
-              refresh: sync,
-              options: syncOptions,
               lastSync,
-              updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
-              onError: onGetError,
-              retryNum: 0,
-              cancelRetry: false
-            };
-            let modeBeforeReset = void 0;
-            const beforeGetParams = {
-              value: getParams.value,
-              lastSync,
-              pendingChanges: pending && !isEmpty(pending) ? pending : void 0,
-              clearPendingChanges: async () => {
-                localState.pendingChanges = {};
-                await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
-                  pending: localState.pendingChanges
-                });
-              },
-              resetCache: () => {
-                var _a3;
-                modeBeforeReset = getParams.mode;
-                getParams.mode = "set";
-                return (_a3 = syncStateValue.resetPersistence) == null ? void 0 : _a3.call(syncStateValue);
+              update: (params) => {
+                when(
+                  () => !get || syncState$.isLoaded.get(),
+                  () => {
+                    when(waitFor || true, () => {
+                      params.mode || (params.mode = syncOptions.mode || "merge");
+                      onChange(params);
+                      if (!syncState$.isLoaded.peek()) {
+                        syncState$.assign({
+                          isLoaded: syncStateValue.numPendingRemoteLoads < 1,
+                          error: void 0,
+                          isGetting: syncStateValue.numPendingGets > 0
+                        });
+                      }
+                    });
+                  }
+                );
               },
-              cancel: false
+              refresh: () => when(syncState$.isLoaded, sync),
+              onError: (error) => onGetError(error, {
+                source: "subscribe",
+                subscribeParams,
+                type: "get",
+                retry: {}
+              })
             };
-            (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, beforeGetParams);
-            if (!beforeGetParams.cancel) {
-              syncState$.assign({
-                numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
-                isGetting: true
-              });
-              const got = runWithRetry(getParams, syncOptions.retry, node, (retryEvent) => {
-                const params = getParams;
-                params.cancelRetry = retryEvent.cancelRetry;
-                params.retryNum = retryEvent.retryNum;
-                return get(params);
+            unsubscribe = subscribe2(subscribeParams);
+            registerMiddleware(node, "listeners-cleared", () => {
+              if (unsubscribe) {
+                isSubscribed = false;
+                unsubscribe();
+                unsubscribe = void 0;
+              }
+            });
+            registerMiddleware(node, "listener-added", () => {
+              if (!isSubscribed) {
+                doSubscribe();
+              }
+            });
+          };
+          if (waitFor) {
+            whenReady(waitFor, doSubscribe);
+          } else {
+            doSubscribe();
+          }
+        }
+        const existingValue = getNodeValue(node);
+        if (get) {
+          const getParams = {
+            node,
+            value$: obs$,
+            value: isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
+            mode: syncOptions.mode,
+            refresh: sync,
+            options: syncOptions,
+            lastSync,
+            updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
+            onError: onGetError,
+            retryNum: 0,
+            cancelRetry: false
+          };
+          let modeBeforeReset = void 0;
+          const beforeGetParams = {
+            value: getParams.value,
+            lastSync,
+            pendingChanges: pending && !isEmpty(pending) ? pending : void 0,
+            clearPendingChanges: async () => {
+              localState.pendingChanges = {};
+              await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+                pending: localState.pendingChanges
               });
-              const numGets = node.numGets = (node.numGets || 0) + 1;
-              const handle = (value) => {
-                syncState$.numPendingGets.set((v) => v - 1);
-                if (isWaitingForLoad) {
-                  isWaitingForLoad = false;
-                  syncStateValue.numPendingRemoteLoads--;
-                }
-                if (numGets >= (node.getNumResolved || 0)) {
-                  node.getNumResolved = node.numGets;
-                  onChange({
-                    value,
-                    lastSync: getParams.lastSync,
-                    mode: getParams.mode
-                  });
-                }
-                if (modeBeforeReset) {
-                  getParams.mode = modeBeforeReset;
-                  modeBeforeReset = void 0;
-                }
-                syncState$.assign({
-                  isLoaded: syncStateValue.numPendingRemoteLoads < 1,
-                  error: void 0,
-                  isGetting: syncStateValue.numPendingGets > 0
-                });
-              };
-              if (isPromise$1(got)) {
-                got.then(handle).catch((error) => {
-                  onGetError(
-                    error,
-                    { getParams, source: "get", type: "get", retry: getParams },
-                    true
-                  );
+            },
+            resetCache: () => {
+              var _a3;
+              modeBeforeReset = getParams.mode;
+              getParams.mode = "set";
+              return (_a3 = syncStateValue.resetPersistence) == null ? void 0 : _a3.call(syncStateValue);
+            },
+            cancel: false
+          };
+          (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, beforeGetParams);
+          if (!beforeGetParams.cancel) {
+            syncState$.assign({
+              numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
+              isGetting: true
+            });
+            const got = runWithRetry(getParams, syncOptions.retry, node, (retryEvent) => {
+              const params = getParams;
+              params.cancelRetry = retryEvent.cancelRetry;
+              params.retryNum = retryEvent.retryNum;
+              return get(params);
+            });
+            const numGets = node.numGets = (node.numGets || 0) + 1;
+            const handle = (value) => {
+              syncState$.numPendingGets.set((v) => v - 1);
+              if (isWaitingForLoad) {
+                isWaitingForLoad = false;
+                syncStateValue.numPendingRemoteLoads--;
+              }
+              if (numGets >= (node.getNumResolved || 0)) {
+                node.getNumResolved = node.numGets;
+                onChange({
+                  value,
+                  lastSync: getParams.lastSync,
+                  mode: getParams.mode
                 });
-              } else {
-                handle(got);
               }
+              if (modeBeforeReset) {
+                getParams.mode = modeBeforeReset;
+                modeBeforeReset = void 0;
+              }
+              syncState$.assign({
+                isLoaded: syncStateValue.numPendingRemoteLoads < 1,
+                error: void 0,
+                isGetting: syncStateValue.numPendingGets > 0
+              });
+            };
+            if (isPromise$1(got)) {
+              got.then(handle).catch((error) => {
+                onGetError(error, { getParams, source: "get", type: "get", retry: getParams }, true);
+              });
+            } else {
+              handle(got);
             }
           }
-        };
-        if (waitFor) {
-          whenReady(waitFor, () => trackSelector(runGet, sync));
-        } else {
-          trackSelector(runGet, sync);
         }
+      };
+      if (waitFor) {
+        whenReady(waitFor, () => trackSelector(runGet, sync));
       } else {
-        syncState$.assign({
-          isLoaded: true,
-          error: void 0
-        });
+        trackSelector(runGet, sync);
       }
       if (!isSynced) {
         isSynced = true;