@legendapp/state 3.0.0-beta.2 → 3.0.0-beta.21

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,23 @@ 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, deepMerge, getNode, getNodeValue, getValueAtPath, globalState, symbolLinked, createPreviousHandler } = state.internal;
 var mapSyncPlugins = /* @__PURE__ */ new WeakMap();
 var allSyncStates = /* @__PURE__ */ new Map();
 var metadatas = /* @__PURE__ */ new WeakMap();
@@ -223,7 +245,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 +297,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 +319,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 +619,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 +632,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 +676,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 +709,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 +784,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 +816,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--;
@@ -808,14 +862,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 +889,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,8 +932,7 @@ 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) {
+      if (get || subscribe) {
         const { waitFor } = syncOptions;
         const runGet = () => {
           var _a2;
@@ -881,11 +951,11 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                   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;
+                    const oldValue = clone2(value);
+                    pending2[key].p = key ? oldValue[key] : oldValue;
                     if (state.isObject(value) && state.isObject(v)) {
-                      Object.assign(value, v);
-                    } else {
+                      Object.assign(value, key ? { [key]: v } : v);
+                    } else if (!key) {
                       value = v;
                     }
                   } else if (value[p[0]] !== void 0) {
@@ -895,8 +965,9 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                       delete pending2[key];
                       didChangeMetadata = true;
                     } else {
-                      const oldValue = clone(value);
+                      const oldValue = clone2(value);
                       pending2[key].p = getValueAtPath(oldValue, p);
+                      didChangeMetadata = true;
                       value = state.setAtPath(
                         value,
                         p,
@@ -917,12 +988,12 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                   }
                 });
                 if (didChangeMetadata && syncOptions.persist) {
-                  updateMetadata(obs$, localState, syncState$, syncOptions, {
+                  updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
                     pending: pending2
                   });
                 }
               }
-              onChangeRemote(() => {
+              onChangeRemote2(() => {
                 if (state.isPlainObject(value)) {
                   value = state.ObservableHint.plain(value);
                 }
@@ -955,7 +1026,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
             node.activationState.onChange = onChange;
           }
           if (!isSubscribed && syncOptions.subscribe) {
-            const subscribe = syncOptions.subscribe;
+            const subscribe2 = syncOptions.subscribe;
             isSubscribed = true;
             const doSubscribe = () => {
               const subscribeParams = {
@@ -963,17 +1034,32 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                 value$: obs$,
                 lastSync,
                 update: (params) => {
-                  state.when(syncState$.isLoaded, () => {
-                    state.when(waitFor || true, () => {
-                      params.mode || (params.mode = syncOptions.mode || "merge");
-                      onChange(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 })
+                onError: (error) => onGetError(error, {
+                  source: "subscribe",
+                  subscribeParams,
+                  type: "get",
+                  retry: {}
+                })
               };
-              unsubscribe = subscribe(subscribeParams);
+              unsubscribe = subscribe2(subscribeParams);
             };
             if (waitFor) {
               state.whenReady(waitFor, doSubscribe);
@@ -982,85 +1068,87 @@ function syncObservable(obs$, syncOptionsOrSynced) {
             }
           }
           const existingValue = getNodeValue(node);
-          const onError = (error) => onGetError(error, { getParams, source: "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,
-            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
+          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
+                });
+              },
+              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
               });
-            },
-            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,
-              (retryEvent) => {
+              const got = runWithRetry(getParams, syncOptions.retry, node, (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
+              });
+              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
+                  );
+                });
+              } 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(onError);
-            } else {
-              handle(got);
             }
           }
         };
@@ -1077,14 +1165,17 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       }
       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 +1201,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 +1223,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 +1306,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;