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

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,13 +172,13 @@ 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));
       }
       return new Promise((resolve, reject) => {
         const run = () => {
@@ -178,9 +189,6 @@ function runWithRetry(state, retryOptions, fn, onError) {
             if (timeoutRetry) {
               clearTimeout(timeoutRetry);
             }
-            if (onError) {
-              onError(error, state);
-            }
             if (!state.cancelRetry) {
               const timeout = createRetryTimeout(retryOptions, state.retryNum, () => {
                 value = fn(state);
@@ -190,7 +198,7 @@ function runWithRetry(state, retryOptions, fn, onError) {
                 state.cancelRetry = true;
                 reject(error);
               } else {
-                mapRetryTimeouts.set(state.node, timeout);
+                mapRetryTimeouts.set(retryId, timeout);
                 timeoutRetry = timeout;
               }
             }
@@ -210,9 +218,33 @@ 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
+} = state.internal;
 var mapSyncPlugins = /* @__PURE__ */ new WeakMap();
 var allSyncStates = /* @__PURE__ */ new Map();
 var metadatas = /* @__PURE__ */ new WeakMap();
@@ -223,7 +255,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();
@@ -275,10 +307,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();
@@ -297,8 +329,25 @@ function mergeChanges(changes) {
         existing.valueAtPath = change.valueAtPath;
       }
     } 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 +629,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 +642,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 +686,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 +719,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 +794,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 +826,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 +845,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 +877,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,30 +904,37 @@ 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;
     }
   };
-  if (syncOptions.get) {
+  const { get, subscribe } = syncOptions;
+  if (get || subscribe) {
     sync = async () => {
       var _a;
       if (isSynced && (!getNodeValue(getNode(syncState$)).isSyncEnabled || state.shouldIgnoreUnobserved(node, sync))) {
@@ -861,128 +947,154 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       }
       const lastSync = (_a = metadatas.get(obs$)) == null ? void 0 : _a.lastSync;
       const pending = localState.pendingChanges;
-      const get = syncOptions.get;
-      if (get) {
-        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 = 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");
+      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;
                   }
-                  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 (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 (lastSync2 && syncOptions.persist) {
+            updateMetadata(obs$, localState, syncState$, syncOptions, {
+              lastSync: lastSync2
+            });
           }
-          if (!isSubscribed && syncOptions.subscribe) {
-            const subscribe = syncOptions.subscribe;
+        };
+        if (node.activationState) {
+          node.activationState.onChange = onChange;
+        }
+        if (!isSubscribed && syncOptions.subscribe) {
+          const subscribe2 = syncOptions.subscribe;
+          const doSubscribe = () => {
             isSubscribed = true;
-            const doSubscribe = () => {
-              const subscribeParams = {
-                node,
-                value$: obs$,
-                lastSync,
-                update: (params) => {
-                  state.when(syncState$.isLoaded, () => {
+            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 = subscribe(subscribeParams);
+                  }
+                );
+              },
+              refresh: () => state.when(syncState$.isLoaded, sync),
+              onError: (error) => onGetError(error, {
+                source: "subscribe",
+                subscribeParams,
+                type: "get",
+                retry: {}
+              })
             };
-            if (waitFor) {
-              state.whenReady(waitFor, doSubscribe);
-            } else {
-              doSubscribe();
-            }
+            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);
-          const onError = (error) => onGetError(error, { getParams, source: "get" });
+        }
+        const existingValue = getNodeValue(node);
+        if (get) {
           const getParams = {
             node,
             value$: obs$,
@@ -992,7 +1104,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
             options: syncOptions,
             lastSync,
             updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
-            onError,
+            onError: onGetError,
             retryNum: 0,
             cancelRetry: false
           };
@@ -1021,17 +1133,12 @@ function syncObservable(obs$, syncOptionsOrSynced) {
               numPendingGets: (syncStateValue.numPendingGets || 0) + 1,
               isGetting: true
             });
-            const got = runWithRetry(
-              getParams,
-              syncOptions.retry,
-              (retryEvent) => {
-                const params = getParams;
-                params.cancelRetry = retryEvent.cancelRetry;
-                params.retryNum = retryEvent.retryNum;
-                return get(params);
-              },
-              onError
-            );
+            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);
@@ -1058,33 +1165,33 @@ function syncObservable(obs$, syncOptionsOrSynced) {
               });
             };
             if (state.isPromise(got)) {
-              got.then(handle).catch(onError);
+              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;
-        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 () => {
@@ -1110,7 +1217,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
     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,7 +1239,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
     return true;
   };
   state.when(onAllPersistLoaded, function() {
-    if (syncOptions.get && syncOptions.syncMode === "auto") {
+    if ((syncOptions.get || syncOptions.subscribe) && syncOptions.syncMode === "auto") {
       sync();
     }
     if ((syncOptions == null ? void 0 : syncOptions.set) || (syncOptions == null ? void 0 : syncOptions.persist)) {
@@ -1215,19 +1322,21 @@ 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.internal = internal5;
 exports.mapSyncPlugins = mapSyncPlugins;
-exports.onChangeRemote = onChangeRemote;
+exports.onChangeRemote = onChangeRemote2;
 exports.removeNullUndefined = removeNullUndefined;
 exports.syncObservable = syncObservable;
 exports.synced = synced;