@legendapp/state 3.0.0-beta.4 → 3.0.0-beta.41

package/sync.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var state = require('@legendapp/state');
+var sync = require('@legendapp/state/sync');
 
 // src/sync/configureObservableSync.ts
 var observableSyncConfiguration = {};
@@ -35,12 +36,12 @@ function diffObjects(obj1, obj2, deep = false) {
   return diff;
 }
 function deepEqual(a, b, ignoreFields, nullVsUndefined) {
-  if (a === b) {
+  if (a === b)
     return true;
-  }
-  if (state.isNullOrUndefined(a) !== state.isNullOrUndefined(b)) {
+  if (state.isNullOrUndefined(a) !== state.isNullOrUndefined(b))
     return false;
-  }
+  if (!state.isObject(a) || !state.isObject(b))
+    return a === b;
   if (nullVsUndefined) {
     a = removeNullUndefined(
       a,
@@ -53,8 +54,18 @@ function deepEqual(a, b, ignoreFields, nullVsUndefined) {
       true
     );
   }
-  const replacer = ignoreFields ? (key, value) => ignoreFields.includes(key) ? void 0 : value : void 0;
-  return JSON.stringify(a, replacer) === JSON.stringify(b, replacer);
+  const keysA = Object.keys(a).filter((key) => !(ignoreFields == null ? void 0 : ignoreFields.includes(key)));
+  const keysB = Object.keys(b).filter((key) => !(ignoreFields == null ? void 0 : ignoreFields.includes(key)));
+  if (keysA.length !== keysB.length)
+    return false;
+  return keysA.every((key) => {
+    if (!Object.prototype.hasOwnProperty.call(b, key))
+      return false;
+    if (state.isDate(a[key]) && state.isDate(b[key])) {
+      return a[key].getTime() === b[key].getTime();
+    }
+    return deepEqual(a[key], b[key], ignoreFields, nullVsUndefined);
+  });
 }
 function combineTransforms(...transforms) {
   return {
@@ -161,38 +172,50 @@ function createRetryTimeout(retryOptions, retryNum, fn) {
   }
 }
 var mapRetryTimeouts = /* @__PURE__ */ new Map();
-function runWithRetry(state, retryOptions, fn, onError) {
+function runWithRetry(state, retryOptions, retryId, fn) {
   try {
     let value = fn(state);
     if (isPromise(value) && retryOptions) {
       let timeoutRetry;
-      if (mapRetryTimeouts.has(state.node)) {
-        clearTimeout(mapRetryTimeouts.get(state.node));
+      if (mapRetryTimeouts.has(retryId)) {
+        clearTimeout(mapRetryTimeouts.get(retryId));
+        mapRetryTimeouts.delete(retryId);
       }
+      const clearRetryState = () => {
+        if (timeoutRetry !== void 0) {
+          clearTimeout(timeoutRetry);
+          timeoutRetry = void 0;
+        }
+        mapRetryTimeouts.delete(retryId);
+      };
       return new Promise((resolve, reject) => {
         const run = () => {
           value.then((val) => {
+            state.retryNum = 0;
+            clearRetryState();
             resolve(val);
           }).catch((error) => {
-            state.retryNum++;
-            if (timeoutRetry) {
+            if (timeoutRetry !== void 0) {
               clearTimeout(timeoutRetry);
+              timeoutRetry = void 0;
             }
-            if (onError) {
-              onError(error, state);
+            state.retryNum++;
+            if (state.cancelRetry) {
+              clearRetryState();
+              reject(error);
+              return;
             }
-            if (!state.cancelRetry) {
-              const timeout = createRetryTimeout(retryOptions, state.retryNum, () => {
-                value = fn(state);
-                run();
-              });
-              if (timeout === false) {
-                state.cancelRetry = true;
-                reject(error);
-              } else {
-                mapRetryTimeouts.set(state.node, timeout);
-                timeoutRetry = timeout;
-              }
+            const timeout = createRetryTimeout(retryOptions, state.retryNum, () => {
+              value = fn(state);
+              run();
+            });
+            if (timeout === false) {
+              state.cancelRetry = true;
+              clearRetryState();
+              reject(error);
+            } else {
+              timeoutRetry = timeout;
+              mapRetryTimeouts.set(retryId, timeout);
             }
           });
         };
@@ -201,6 +224,7 @@ function runWithRetry(state, retryOptions, fn, onError) {
     }
     return value;
   } catch (error) {
+    mapRetryTimeouts.delete(retryId);
     return Promise.reject(error);
   }
 }
@@ -210,9 +234,34 @@ async function waitForSet(waitForSet2, changes, value, params = {}) {
     await state.when(waitFn);
   }
 }
+var { clone } = state.internal;
+function createRevertChanges(obs$, changes) {
+  return () => {
+    const previous = state.applyChanges(
+      clone(obs$.peek()),
+      changes,
+      /*applyPrevious*/
+      true
+    );
+    sync.onChangeRemote(() => {
+      obs$.set(previous);
+    });
+  };
+}
 
 // src/sync/syncObservable.ts
-var { clone, deepMerge, getNode, getNodeValue, getValueAtPath, globalState, symbolLinked, createPreviousHandler } = state.internal;
+var {
+  clone: clone2,
+  createPreviousHandler,
+  deepMerge,
+  getNode,
+  getNodeValue,
+  getValueAtPath,
+  globalState,
+  registerMiddleware,
+  symbolLinked,
+  setNodeValue
+} = state.internal;
 var mapSyncPlugins = /* @__PURE__ */ new WeakMap();
 var allSyncStates = /* @__PURE__ */ new Map();
 var metadatas = /* @__PURE__ */ new WeakMap();
@@ -223,7 +272,7 @@ function parseLocalConfig(config) {
 function doInOrder(arg1, arg2) {
   return state.isPromise(arg1) ? arg1.then(arg2) : arg2(arg1);
 }
-function onChangeRemote(cb) {
+function onChangeRemote2(cb) {
   state.endBatch(true);
   globalState.isLoadingRemote = true;
   state.beginBatch();
@@ -251,7 +300,7 @@ function transformLoadData(value, { transform }, doUserTransform, method) {
   }
   return value;
 }
-async function updateMetadataImmediate(value$, localState, syncState2, syncOptions, newMetadata) {
+async function updateMetadataImmediate(value$, localState, syncState$, syncOptions, newMetadata) {
   const saves = Array.from(promisesLocalSaves);
   if (saves.length > 0) {
     await Promise.all(saves);
@@ -266,7 +315,7 @@ async function updateMetadataImmediate(value$, localState, syncState2, syncOptio
     await pluginPersist.setMetadata(table, metadata, config);
   }
   if (lastSync) {
-    syncState2.assign({
+    syncState$.assign({
       lastSync
     });
   }
@@ -275,10 +324,10 @@ function updateMetadata(value$, localState, syncState2, syncOptions, newMetadata
   if (localState.timeoutSaveMetadata) {
     clearTimeout(localState.timeoutSaveMetadata);
   }
-  localState.timeoutSaveMetadata = setTimeout(
-    () => updateMetadataImmediate(value$, localState, syncState2, syncOptions, newMetadata),
-    0
-  );
+  metadatas.set(value$, { ...metadatas.get(value$) || {}, ...newMetadata });
+  localState.timeoutSaveMetadata = setTimeout(() => {
+    updateMetadataImmediate(value$, localState, syncState2, syncOptions, metadatas.get(value$));
+  }, 0);
 }
 var _queuedChanges = [];
 var _queuedRemoteChanges = /* @__PURE__ */ new Map();
@@ -292,13 +341,35 @@ function mergeChanges(changes) {
     const existing = changesByPath.get(pathStr);
     if (existing) {
       if (change.valueAtPath === existing.prevAtPath) {
-        changesOut.splice(changesOut.indexOf(change), 1);
+        const idx = changesOut.indexOf(existing);
+        if (idx >= 0) {
+          changesOut.splice(idx, 1);
+        }
+        changesByPath.delete(pathStr);
       } else {
         existing.valueAtPath = change.valueAtPath;
+        existing.pathTypes = change.pathTypes;
       }
     } else {
-      changesByPath.set(pathStr, change);
-      changesOut.push(change);
+      let found = false;
+      for (let u = 0; u < change.path.length; u++) {
+        const path = change.path.slice(0, u).join("/");
+        if (changesByPath.has(path)) {
+          const remaining = change.path.slice(u);
+          state.setAtPath(
+            changesByPath.get(path).valueAtPath,
+            remaining,
+            change.pathTypes.slice(u),
+            change.valueAtPath
+          );
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        changesByPath.set(pathStr, change);
+        changesOut.push(change);
+      }
     }
   }
   return changesOut;
@@ -580,7 +651,7 @@ async function doChangeRemote(changeInfo) {
     if (waitForSetParam) {
       await waitForSet(waitForSetParam, changesRemote, obs$.peek());
     }
-    let value = clone(obs$.peek());
+    let value = clone2(obs$.peek());
     const transformSave = (_a = syncOptions == null ? void 0 : syncOptions.transform) == null ? void 0 : _a.save;
     if (transformSave) {
       value = transformSave(value);
@@ -593,33 +664,41 @@ async function doChangeRemote(changeInfo) {
     onBeforeSet == null ? void 0 : onBeforeSet(beforeSetParams);
     if (!beforeSetParams.cancel) {
       let updateResult = void 0;
-      let errorHandled = false;
-      const onError = (error, retryParams) => {
+      let lastErrorHandled;
+      const onSetError = (error, params, noThrow) => {
         var _a2;
-        state$.error.set(error);
-        if (!errorHandled) {
-          (_a2 = syncOptions.onError) == null ? void 0 : _a2.call(syncOptions, error, {
-            setParams,
-            source: "set",
-            value$: obs$,
-            retryParams
-          });
+        if (lastErrorHandled !== error) {
+          if (!params) {
+            params = {
+              setParams,
+              source: "set",
+              type: "set",
+              input: value,
+              retry: setParams,
+              revert: createRevertChanges(setParams.value$, setParams.changes)
+            };
+          }
+          state$.error.set(error);
+          (_a2 = syncOptions.onError) == null ? void 0 : _a2.call(syncOptions, error, params);
+          lastErrorHandled = error;
+          if (!noThrow) {
+            throw error;
+          }
         }
-        errorHandled = true;
       };
       const setParams = {
         node,
         value$: obs$,
         changes: changesRemote,
         value,
-        onError,
+        onError: onSetError,
         update: (params) => {
           if (updateResult) {
-            const { value: value2, lastSync, mode } = params;
+            const { value: value2, mode, changes } = params;
             updateResult = {
-              lastSync: Math.max(updateResult.lastSync || 0, lastSync || 0),
               value: deepMerge(updateResult.value, value2),
-              mode
+              mode,
+              changes: changes ? [...updateResult.changes || [], ...changes] : updateResult.changes
             };
           } else {
             updateResult = params;
@@ -629,26 +708,23 @@ async function doChangeRemote(changeInfo) {
         retryNum: 0,
         cancelRetry: false
       };
-      const savedPromise = runWithRetry(
-        setParams,
-        syncOptions.retry,
-        async () => {
-          return syncOptions.set(setParams);
-        },
-        onError
-      );
+      const savedPromise = runWithRetry(setParams, syncOptions.retry, node, async () => {
+        return syncOptions.set(setParams);
+      });
       let didError = false;
       if (state.isPromise(savedPromise)) {
         await savedPromise.catch((error) => {
           didError = true;
           if (!syncOptions.retry) {
-            onError(error);
+            onSetError(error, void 0, true);
           }
         });
       }
-      if (!didError) {
-        const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
-        const { value: changes, lastSync } = updateResult || {};
+      if (!didError || (updateResult == null ? void 0 : updateResult.changes)) {
+        const { value: updateValue, changes: updateChanges = changesRemote } = updateResult || {};
+        const pathStrs = Array.from(
+          new Set(updateChanges.map((change) => change.pathStr))
+        );
         if (pathStrs.length > 0) {
           let transformedChanges = void 0;
           const metadata = {};
@@ -665,18 +741,15 @@ async function doChangeRemote(changeInfo) {
                 delete pending[pathStr];
               }
             }
-            if (lastSync) {
-              metadata.lastSync = lastSync;
-            }
           }
-          if (changes && !state.isEmpty(changes)) {
-            transformedChanges = transformLoadData(changes, syncOptions, false, "set");
+          if (updateValue && !state.isEmpty(updateValue)) {
+            transformedChanges = transformLoadData(updateValue, syncOptions, false, "set");
           }
           if (transformedChanges !== void 0) {
             if (state.isPromise(transformedChanges)) {
               transformedChanges = await transformedChanges;
             }
-            onChangeRemote(() => state.mergeIntoObservable(obs$, transformedChanges));
+            onChangeRemote2(() => state.mergeIntoObservable(obs$, transformedChanges));
           }
           if (saveLocal) {
             if (shouldSaveMetadata && !state.isEmpty(metadata)) {
@@ -743,9 +816,20 @@ async function loadLocal(value$, syncOptions, syncState$, localState) {
       await state.when(initialized$);
     }
     if (persistPlugin.loadTable) {
-      const promise = persistPlugin.loadTable(table, config);
-      if (promise) {
-        await promise;
+      try {
+        const promise = persistPlugin.loadTable(table, config);
+        if (promise) {
+          await promise;
+        }
+      } catch (err) {
+        if (process.env.NODE_ENV === "development") {
+          console.error(
+            "[legend-state] Error loading local cache. This would be a crashing error in production.",
+            err
+          );
+        } else {
+          throw err;
+        }
       }
     }
     const prevValue = getNodeValue(node);
@@ -764,12 +848,14 @@ async function loadLocal(value$, syncOptions, syncState$, localState) {
       if (state.isPromise(value)) {
         value = await value;
       }
+      node.root.isLoadingLocal = true;
       state.internal.globalState.isLoadingLocal = true;
       if (value === null && (!prevValue || prevValue[symbolLinked])) {
         value$.set(value);
       } else {
         state.mergeIntoObservable(value$, value);
       }
+      node.root.isLoadingLocal = false;
       state.internal.globalState.isLoadingLocal = false;
     }
     syncStateValue.numPendingLocalLoads--;
@@ -781,6 +867,11 @@ async function loadLocal(value$, syncOptions, syncState$, localState) {
       ].filter(Boolean)
     );
   } else {
+    if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && persist && persist.plugin && !Object.hasOwn(persist, "name")) {
+      console.warn(
+        "[legend-state] Trying to syncObservable without `name` defined. Please include a `name` property in the `persist` configuration."
+      );
+    }
     nodeValue.resetPersistence = () => prevResetPersistence == null ? void 0 : prevResetPersistence();
   }
   nodeValue.clearPersist = nodeValue.resetPersistence;
@@ -808,14 +899,24 @@ function syncObservable(obs$, syncOptionsOrSynced) {
   const syncStateValue = getNodeValue(getNode(syncState$));
   allSyncStates.set(syncState$, node);
   syncStateValue.getPendingChanges = () => localState.pendingChanges;
-  let errorHandled = false;
-  const onGetError = (error, params) => {
+  let lastErrorHandled;
+  const onGetError = (error, params, noThrow) => {
     var _a;
-    syncState$.error.set(error);
-    if (!errorHandled) {
-      (_a = syncOptions.onError) == null ? void 0 : _a.call(syncOptions, error, { ...params, value$: obs$ });
+    if (lastErrorHandled !== error) {
+      if (!params) {
+        params = {
+          source: "get",
+          type: "get",
+          retry: params
+        };
+      }
+      syncState$.error.set(error);
+      (_a = syncOptions.onError) == null ? void 0 : _a.call(syncOptions, error, params);
+      lastErrorHandled = error;
+      if (!noThrow) {
+        throw error;
+      }
     }
-    errorHandled = true;
   };
   loadLocal(obs$, syncOptions, syncState$, localState);
   let isWaitingForLoad = !!syncOptions.get;
@@ -825,33 +926,39 @@ function syncObservable(obs$, syncOptionsOrSynced) {
   syncState$.isLoaded.set(!syncState$.numPendingRemoteLoads.peek());
   let isSynced = false;
   let isSubscribed = false;
+  let isApplyingPendingAfterSync = false;
   let unsubscribe = void 0;
   const applyPending = (pending) => {
     if (pending && !state.isEmpty(pending)) {
-      localState.isApplyingPending = true;
       const keys = Object.keys(pending);
+      const value = getNodeValue(node);
       const changes = [];
       for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
         const path = key.split("/").filter((p2) => p2 !== "");
-        const { p, v, t } = pending[key];
-        changes.push({ path, valueAtPath: v, prevAtPath: p, pathTypes: t });
+        const { p, t, v } = pending[key];
+        const valueAtPath = getValueAtPath(value, path);
+        if (isApplyingPendingAfterSync || !deepEqual(valueAtPath, v)) {
+          changes.push({ path, valueAtPath: v, prevAtPath: p, pathTypes: t });
+        }
+      }
+      if (changes.length > 0) {
+        localState.isApplyingPending = true;
+        onObsChange(obs$, syncState$, localState, syncOptions, {
+          value,
+          isFromPersist: false,
+          isFromSync: false,
+          getPrevious: createPreviousHandler(value, changes),
+          changes
+        });
+        localState.isApplyingPending = false;
       }
-      const value = getNodeValue(node);
-      onObsChange(obs$, syncState$, localState, syncOptions, {
-        value,
-        isFromPersist: false,
-        isFromSync: false,
-        getPrevious: createPreviousHandler(value, changes),
-        changes
-      });
-      localState.isApplyingPending = false;
     }
   };
   const { get, subscribe } = syncOptions;
   if (get || subscribe) {
-    sync = async () => {
-      var _a;
+    const callSync = () => sync();
+    sync = async (options) => {
       if (isSynced && (!getNodeValue(getNode(syncState$)).isSyncEnabled || state.shouldIgnoreUnobserved(node, sync))) {
         if (unsubscribe) {
           isSubscribed = false;
@@ -860,243 +967,262 @@ function syncObservable(obs$, syncOptionsOrSynced) {
         }
         return;
       }
-      const lastSync = (_a = metadatas.get(obs$)) == null ? void 0 : _a.lastSync;
+      const metadata = metadatas.get(obs$);
+      if (metadata && (options == null ? void 0 : options.resetLastSync)) {
+        metadata.lastSync = void 0;
+        syncState$.lastSync.set(void 0);
+      }
+      const lastSync = metadata == null ? void 0 : metadata.lastSync;
       const pending = localState.pendingChanges;
-      if (get || subscribe) {
-        const { waitFor } = syncOptions;
-        const runGet = () => {
+      const { waitFor } = syncOptions;
+      const runGet = () => {
+        var _a;
+        const onChange = async ({ value, mode, lastSync: lastSync2 }) => {
           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 = clone(value);
-                    pending2[key].p = oldValue;
-                    if (state.isObject(value) && state.isObject(v)) {
-                      Object.assign(value, v);
-                    } else {
-                      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 = clone(value);
-                      pending2[key].p = getValueAtPath(oldValue, p);
-                      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) {
-                  updateMetadata(obs$, localState, syncState$, syncOptions, {
-                    pending: pending2
-                  });
-                }
-              }
-              onChangeRemote(() => {
-                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");
+          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;
                   }
-                  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");
+                } 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)
+                        };
+                      }
+                    );
                   }
-                  obs$.splice(0, 0, ...value);
-                } else if (mode === "merge") {
-                  state.mergeIntoObservable(obs$, value);
-                } else {
-                  obs$.set(value);
                 }
               });
+              if (didChangeMetadata && syncOptions.persist) {
+                updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+                  pending: pending2
+                });
+              }
             }
-            if (lastSync2 && syncOptions.persist) {
-              updateMetadata(obs$, localState, syncState$, syncOptions, {
-                lastSync: lastSync2
-              });
+            if (options == null ? void 0 : options.resetLastSync) {
+              setNodeValue(node, (_a2 = syncOptions.initial) != null ? _a2 : void 0);
             }
-          };
-          if (node.activationState) {
-            node.activationState.onChange = onChange;
+            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");
+                }
+                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);
+              }
+            });
           }
-          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 })
-              };
-              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 onError = (error) => onGetError(error, { getParams, source: "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,
-              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, callSync),
+              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
+            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 got = runWithRetry(
-                getParams,
-                syncOptions.retry,
-                (retryEvent) => {
-                  const params = getParams;
-                  params.cancelRetry = retryEvent.cancelRetry;
-                  params.retryNum = retryEvent.retryNum;
-                  return get(params);
-                },
-                onError
-              );
-              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
+            },
+            resetCache: () => {
+              var _a2;
+              modeBeforeReset = getParams.mode;
+              getParams.mode = "set";
+              return (_a2 = syncStateValue.resetPersistence) == null ? void 0 : _a2.call(syncStateValue);
+            },
+            cancel: false
+          };
+          (_a = syncOptions.onBeforeGet) == null ? void 0 : _a.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
                 });
-              };
-              if (state.isPromise(got)) {
-                got.then(handle).catch(onError);
-              } 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, callSync));
       } else {
-        syncState$.assign({
-          isLoaded: true,
-          error: void 0
-        });
+        state.trackSelector(runGet, callSync);
       }
       if (!isSynced) {
         isSynced = true;
-        await state.when(syncState$.isLoaded);
+        isApplyingPendingAfterSync = true;
         applyPending(pending);
+        isApplyingPendingAfterSync = false;
       }
     };
     syncStateValue.sync = sync;
   } else {
     if (!isSynced) {
+      isApplyingPendingAfterSync = true;
       applyPending(localState.pendingChanges);
+      isApplyingPendingAfterSync = false;
     }
   }
   syncStateValue.reset = async () => {
@@ -1106,7 +1232,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
     if (metadata) {
       Object.assign(metadata, { lastSync: void 0, pending: void 0 });
     }
-    Object.assign(syncStateValue, {
+    const newState = {
       isPersistEnabled: false,
       isSyncEnabled: false,
       lastSync: void 0,
@@ -1116,13 +1242,14 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       isSetting: false,
       numPendingSets: 0,
       syncCount: 0
-    });
+    };
+    Object.assign(syncStateValue, newState);
     isSynced = false;
     isSubscribed = false;
     unsubscribe == null ? void 0 : unsubscribe();
     unsubscribe = void 0;
     const promise = syncStateValue.resetPersistence();
-    onChangeRemote(() => {
+    onChangeRemote2(() => {
       var _a;
       obs$.set((_a = syncOptions.initial) != null ? _a : void 0);
     });
@@ -1132,6 +1259,14 @@ function syncObservable(obs$, syncOptionsOrSynced) {
     node.dirtyFn = sync;
     await promise;
   };
+  syncState$.lastSync.onChange(({ value }) => {
+    const metadata = metadatas.get(obs$);
+    if (metadata && metadata.lastSync !== value) {
+      updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+        lastSync: value
+      });
+    }
+  });
   const onAllPersistLoaded = () => {
     var _a, _b;
     let parentNode = node;
@@ -1155,7 +1290,10 @@ function syncObservable(obs$, syncOptionsOrSynced) {
   });
   return syncState$;
 }
-var { getProxy, globalState: globalState2, setNodeValue, getNodeValue: getNodeValue2 } = state.internal;
+function getAllSyncStates() {
+  return Array.from(allSyncStates.entries());
+}
+var { getProxy, globalState: globalState2, setNodeValue: setNodeValue2, getNodeValue: getNodeValue2 } = state.internal;
 function enableActivateSyncedNode() {
   globalState2.activateSyncedNode = function activateSyncedNode(node, newValue) {
     const obs$ = getProxy(node);
@@ -1178,7 +1316,7 @@ function enableActivateSyncedNode() {
       } else {
         newValue = initial;
       }
-      setNodeValue(node, promiseReturn ? void 0 : newValue);
+      setNodeValue2(node, promiseReturn ? void 0 : newValue);
       syncObservable(obs$, { ...node.activationState, get, set });
       return { update: onChange, value: newValue };
     } else {
@@ -1227,19 +1365,22 @@ function configureSynced(fnOrOrigOptions, origOptions) {
 }
 
 // sync.ts
-var internal4 = {
+var internal5 = {
   observableSyncConfiguration,
-  waitForSet
+  waitForSet,
+  runWithRetry
 };
 
 exports.combineTransforms = combineTransforms;
 exports.configureObservableSync = configureObservableSync;
 exports.configureSynced = configureSynced;
+exports.createRevertChanges = createRevertChanges;
 exports.deepEqual = deepEqual;
 exports.diffObjects = diffObjects;
-exports.internal = internal4;
+exports.getAllSyncStates = getAllSyncStates;
+exports.internal = internal5;
 exports.mapSyncPlugins = mapSyncPlugins;
-exports.onChangeRemote = onChangeRemote;
+exports.onChangeRemote = onChangeRemote2;
 exports.removeNullUndefined = removeNullUndefined;
 exports.syncObservable = syncObservable;
 exports.synced = synced;