@legendapp/state 3.0.0-alpha.9 → 3.0.0-beta.1

package/sync.mjs

@@ -1,6 +1,4 @@
-import { isObject, isDate, isNullOrUndefined, isString, endBatch, beginBatch, isFunction, mergeIntoObservable, observable, when, linked, internal, isPromise, isEmpty, shouldIgnoreUnobserved, whenReady, constructObjectWithPath, deconstructObjectWithPath, setAtPath, isArray } from '@legendapp/state';
-
-// sync.ts
+import { isObject, isDate, isNullOrUndefined, isString, endBatch, beginBatch, isFunction, syncState, when, linked, internal, observable, isPromise as isPromise$1, mergeIntoObservable, isEmpty, shouldIgnoreUnobserved, whenReady, trackSelector, constructObjectWithPath, setAtPath, isPlainObject, ObservableHint, isArray } from '@legendapp/state';
 
 // src/sync/configureObservableSync.ts
 var observableSyncConfiguration = {};
@@ -137,41 +135,91 @@ function transformStringifyDates(...args) {
     }
   };
 }
-function syncObservableAdapter({ get, set }) {
-  const ret = {};
-  if (get) {
-    ret.get = async (params) => {
-      try {
-        let value = get(params);
-        if (isPromise(value)) {
-          value = await value;
-        }
-        params.onChange({
-          value,
-          lastSync: params.lastSync,
-          mode: params.mode
-        });
-        params.onGet();
-      } catch (e) {
+
+// src/is.ts
+function isPromise(obj) {
+  return obj instanceof Promise;
+}
+
+// src/sync/retry.ts
+function calculateRetryDelay(retryOptions, retryNum) {
+  const { backoff, delay = 1e3, infinite, times = 3, maxDelay = 3e4 } = retryOptions;
+  if (infinite || retryNum < times) {
+    const delayTime = Math.min(delay * (backoff === "constant" ? 1 : 2 ** retryNum), maxDelay);
+    return delayTime;
+  }
+  return null;
+}
+function createRetryTimeout(retryOptions, retryNum, fn) {
+  const delayTime = calculateRetryDelay(retryOptions, retryNum);
+  if (delayTime) {
+    return setTimeout(fn, delayTime);
+  } else {
+    return false;
+  }
+}
+var mapRetryTimeouts = /* @__PURE__ */ new Map();
+function runWithRetry(state, retryOptions, fn, onError) {
+  try {
+    let value = fn(state);
+    if (isPromise(value) && retryOptions) {
+      let timeoutRetry;
+      if (mapRetryTimeouts.has(state.node)) {
+        clearTimeout(mapRetryTimeouts.get(state.node));
       }
-    };
+      return new Promise((resolve, reject) => {
+        const run = () => {
+          value.then((val) => {
+            resolve(val);
+          }).catch((error) => {
+            state.retryNum++;
+            if (timeoutRetry) {
+              clearTimeout(timeoutRetry);
+            }
+            if (onError) {
+              onError(error, state);
+            }
+            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;
+              }
+            }
+          });
+        };
+        run();
+      });
+    }
+    return value;
+  } catch (error) {
+    return Promise.reject(error);
   }
-  if (set) {
-    ret.set = set;
+}
+async function waitForSet(waitForSet2, changes, value, params = {}) {
+  const waitFn = isFunction(waitForSet2) ? waitForSet2({ changes, value, ...params }) : waitForSet2;
+  if (waitFn) {
+    await when(waitFn);
   }
-  return ret;
 }
 
 // src/sync/syncObservable.ts
-var { createPreviousHandler, clone, getValueAtPath, globalState, symbolLinked, getNode, getNodeValue } = internal;
+var { clone, deepMerge, getNode, getNodeValue, getValueAtPath, globalState, symbolLinked, createPreviousHandler } = internal;
 var mapSyncPlugins = /* @__PURE__ */ new WeakMap();
+var allSyncStates = /* @__PURE__ */ new Map();
 var metadatas = /* @__PURE__ */ new WeakMap();
 var promisesLocalSaves = /* @__PURE__ */ new Set();
 function parseLocalConfig(config) {
   return config ? isString(config) ? { table: config, config: { name: config } } : { table: config.name, config } : {};
 }
 function doInOrder(arg1, arg2) {
-  return isPromise(arg1) ? arg1.then(arg2) : arg2(arg1);
+  return isPromise$1(arg1) ? arg1.then(arg2) : arg2(arg1);
 }
 function onChangeRemote(cb) {
   endBatch(true);
@@ -181,13 +229,19 @@ function onChangeRemote(cb) {
   globalState.isLoadingRemote = false;
   endBatch(true);
 }
-function transformSaveData(value, path, pathTypes, { transform }) {
+async function transformSaveData(value, path, pathTypes, { transform }) {
   if (transform == null ? void 0 : transform.save) {
     const constructed = constructObjectWithPath(path, pathTypes, value);
-    const saved = transform.save(constructed);
-    value = deconstructObjectWithPath(path, pathTypes, saved);
+    const saved = await transform.save(constructed);
+    value = saved;
+    const outPath = [];
+    for (let i = 0; i < path.length; i++) {
+      outPath[i] = Object.keys(value)[0];
+      value = value[outPath[i]];
+    }
+    path = outPath;
   }
-  return value;
+  return { value, path };
 }
 function transformLoadData(value, { transform }, doUserTransform, method) {
   if (doUserTransform && (transform == null ? void 0 : transform.load)) {
@@ -195,13 +249,13 @@ function transformLoadData(value, { transform }, doUserTransform, method) {
   }
   return value;
 }
-async function updateMetadataImmediate(value$, localState, syncState, syncOptions, newMetadata) {
+async function updateMetadataImmediate(value$, localState, syncState2, syncOptions, newMetadata) {
   const saves = Array.from(promisesLocalSaves);
   if (saves.length > 0) {
     await Promise.all(saves);
   }
   const { pluginPersist } = localState;
-  const { table, config } = parseLocalConfig(syncOptions == null ? void 0 : syncOptions.persist);
+  const { table, config } = parseLocalConfig(syncOptions.persist);
   const oldMetadata = metadatas.get(value$);
   const { lastSync } = newMetadata;
   const metadata = Object.assign({}, oldMetadata, newMetadata);
@@ -210,17 +264,17 @@ async function updateMetadataImmediate(value$, localState, syncState, syncOption
     await pluginPersist.setMetadata(table, metadata, config);
   }
   if (lastSync) {
-    syncState.assign({
+    syncState2.assign({
       lastSync
     });
   }
 }
-function updateMetadata(value$, localState, syncState, syncOptions, newMetadata) {
+function updateMetadata(value$, localState, syncState2, syncOptions, newMetadata) {
   if (localState.timeoutSaveMetadata) {
     clearTimeout(localState.timeoutSaveMetadata);
   }
   localState.timeoutSaveMetadata = setTimeout(
-    () => updateMetadataImmediate(value$, localState, syncState, syncOptions, newMetadata),
+    () => updateMetadataImmediate(value$, localState, syncState2, syncOptions, newMetadata),
     0
   );
 }
@@ -248,26 +302,21 @@ function mergeChanges(changes) {
   return changesOut;
 }
 function mergeQueuedChanges(allChanges) {
-  const changesByObsRemote = /* @__PURE__ */ new Map();
-  const changesByObsLocal = /* @__PURE__ */ new Map();
-  const previousByObs = /* @__PURE__ */ new Map();
+  const changesByOptionsRemote = /* @__PURE__ */ new Map();
+  const changesByOptionsLocal = /* @__PURE__ */ new Map();
   const outRemote = /* @__PURE__ */ new Map();
   const outLocal = /* @__PURE__ */ new Map();
   for (let i = 0; i < allChanges.length; i++) {
     const value = allChanges[i];
-    const { value$: obs, changes, inRemoteChange, getPrevious } = value;
+    const { changes, inRemoteChange, syncOptions } = value;
     const targetMap = inRemoteChange ? outRemote : outLocal;
-    const changesMap = inRemoteChange ? changesByObsRemote : changesByObsLocal;
-    const existing = changesMap.get(obs);
+    const changesMap = inRemoteChange ? changesByOptionsRemote : changesByOptionsLocal;
+    const existing = changesMap.get(syncOptions);
     const newChanges = existing ? [...existing, ...changes] : changes;
     const merged = mergeChanges(newChanges);
-    changesMap.set(obs, merged);
+    changesMap.set(syncOptions, merged);
     value.changes = merged;
-    if (!previousByObs.has(obs)) {
-      previousByObs.set(obs, getPrevious());
-    }
-    value.valuePrevious = previousByObs.get(obs);
-    targetMap.set(obs, value);
+    targetMap.set(syncOptions, value);
   }
   return Array.from(outRemote.values()).concat(Array.from(outLocal.values()));
 }
@@ -313,15 +362,13 @@ async function processQueuedRemoteChanges(syncOptions) {
   }
 }
 async function prepChangeLocal(queuedChange) {
-  const { syncState, changes, localState, syncOptions, inRemoteChange, isApplyingPending } = queuedChange;
+  const { syncState: syncState2, changes, syncOptions, inRemoteChange, isApplyingPending } = queuedChange;
   const persist = syncOptions.persist;
-  const { pluginSync } = localState;
   const { config: configLocal } = parseLocalConfig(persist);
-  const configRemote = syncOptions;
-  const saveLocal = (persist == null ? void 0 : persist.name) && !configLocal.readonly && !isApplyingPending && syncState.isPersistEnabled.peek();
-  const saveRemote = !!(!inRemoteChange && (pluginSync == null ? void 0 : pluginSync.set) && (configRemote == null ? void 0 : configRemote.enableSync) !== false && syncState.isSyncEnabled.peek());
+  const saveLocal = (persist == null ? void 0 : persist.name) && !configLocal.readonly && !isApplyingPending && syncState2.isPersistEnabled.peek();
+  const saveRemote = !!(!inRemoteChange && (syncOptions == null ? void 0 : syncOptions.set) && syncState2.isSyncEnabled.peek());
   if (saveLocal || saveRemote) {
-    if (saveLocal && !syncState.isPersistLoaded.peek()) {
+    if (saveLocal && !syncState2.isPersistLoaded.peek()) {
       console.error(
         "[legend-state] WARNING: An observable was changed before being loaded from persist",
         persist
@@ -354,13 +401,13 @@ async function prepChangeLocal(queuedChange) {
             configLocal
           );
           promisesTransform.push(
-            doInOrder(promiseTransformLocal, (valueTransformed) => {
+            doInOrder(promiseTransformLocal, ({ value: valueTransformed, path: pathTransformed }) => {
               changesLocal.push({
-                path,
+                path: pathTransformed,
                 pathTypes,
                 prevAtPath,
                 valueAtPath: valueTransformed,
-                pathStr
+                pathStr: path === pathTransformed ? pathStr : pathTransformed.join("/")
               });
             })
           );
@@ -376,22 +423,19 @@ async function prepChangeLocal(queuedChange) {
 }
 async function prepChangeRemote(queuedChange) {
   const {
-    syncState,
+    syncState: syncState2,
     changes,
     localState,
     syncOptions,
     inRemoteChange,
-    isApplyingPending,
-    valuePrevious
+    isApplyingPending
   } = queuedChange;
   const persist = syncOptions.persist;
-  const { pluginSync } = localState;
   const { config: configLocal } = parseLocalConfig(persist);
-  const configRemote = syncOptions;
-  const saveLocal = persist && !configLocal.readonly && !isApplyingPending && syncState.isPersistEnabled.peek();
-  const saveRemote = !inRemoteChange && (pluginSync == null ? void 0 : pluginSync.set) && (configRemote == null ? void 0 : configRemote.enableSync) !== false && syncState.isSyncEnabled.peek();
+  const saveLocal = persist && !configLocal.readonly && !isApplyingPending && syncState2.isPersistEnabled.peek();
+  const saveRemote = !inRemoteChange && (syncOptions == null ? void 0 : syncOptions.set) && syncState2.isSyncEnabled.peek();
   if (saveLocal || saveRemote) {
-    if (saveLocal && !syncState.isPersistLoaded.peek()) {
+    if (saveLocal && !syncState2.isPersistLoaded.peek()) {
       console.error(
         "[legend-state] WARNING: An observable was changed before being loaded from persist",
         persist
@@ -421,20 +465,20 @@ async function prepChangeRemote(queuedChange) {
             valueAtPath,
             path,
             pathTypes,
-            configRemote || {}
+            syncOptions || {}
           );
           promisesTransform.push(
-            doInOrder(promiseTransformRemote, (valueTransformed) => {
+            doInOrder(promiseTransformRemote, ({ value: valueTransformed, path: pathTransformed }) => {
               var _a;
               if (!localState.pendingChanges) {
                 localState.pendingChanges = {};
               }
               let found2 = false;
-              for (let i2 = 0; !found2 && i2 < path.length - 1; i2++) {
-                const pathParent = path.slice(0, i2 + 1).join("/");
+              for (let i2 = 0; !found2 && i2 < pathTransformed.length - 1; i2++) {
+                const pathParent = pathTransformed.slice(0, i2 + 1).join("/");
                 if ((_a = localState.pendingChanges[pathParent]) == null ? void 0 : _a.v) {
                   found2 = true;
-                  const pathChild = path.slice(i2 + 1);
+                  const pathChild = pathTransformed.slice(i2 + 1);
                   const pathTypesChild = pathTypes.slice(i2 + 1);
                   setAtPath(
                     localState.pendingChanges[pathParent].v,
@@ -456,12 +500,11 @@ async function prepChangeRemote(queuedChange) {
                 localState.pendingChanges[pathStr].v = valueAtPath;
               }
               changesRemote.push({
-                path,
+                path: pathTransformed,
                 pathTypes,
                 prevAtPath,
                 valueAtPath: valueTransformed,
-                pathStr,
-                valuePrevious
+                pathStr
               });
             })
           );
@@ -479,7 +522,7 @@ async function doChangeLocal(changeInfo) {
   if (!changeInfo)
     return;
   const { queuedChange, changesLocal, saveRemote } = changeInfo;
-  const { value$: obs, syncState, localState, syncOptions } = queuedChange;
+  const { value$: obs, syncState: syncState2, localState, syncOptions } = queuedChange;
   const { pluginPersist } = localState;
   const persist = syncOptions.persist;
   const saveLocal = !!(persist == null ? void 0 : persist.name);
@@ -487,7 +530,7 @@ async function doChangeLocal(changeInfo) {
     const { table, config: configLocal } = parseLocalConfig(persist);
     const shouldSaveMetadata = persist == null ? void 0 : persist.retrySync;
     if (saveRemote && shouldSaveMetadata) {
-      await updateMetadataImmediate(obs, localState, syncState, syncOptions, {
+      await updateMetadataImmediate(obs, localState, syncState2, syncOptions, {
         pending: localState.pendingChanges
       });
     }
@@ -508,88 +551,151 @@ async function doChangeRemote(changeInfo) {
   if (!changeInfo)
     return;
   const { queuedChange, changesRemote } = changeInfo;
-  const { value$: obs, syncState, localState, syncOptions, valuePrevious: previous } = queuedChange;
-  const { pluginPersist, pluginSync } = localState;
+  const { value$: obs$, syncState: syncState2, localState, syncOptions } = queuedChange;
+  const { pluginPersist } = localState;
+  const node = getNode(obs$);
+  const state$ = node.state;
   const persist = syncOptions.persist;
   const { table, config: configLocal } = parseLocalConfig(persist);
-  const { allowSetIfGetError, onBeforeSet, onSetError, waitForSet, onAfterSet } = syncOptions || {};
+  const { onBeforeSet, waitForSet: waitForSetParam, onAfterSet } = syncOptions || {};
   const shouldSaveMetadata = persist == null ? void 0 : persist.retrySync;
   const saveLocal = !!(persist == null ? void 0 : persist.name);
   if (changesRemote.length > 0) {
-    await when(() => syncState.isLoaded.get() || allowSetIfGetError && syncState.error.get());
-    if (waitForSet) {
-      const waitFor = isFunction(waitForSet) ? waitForSet({ changes: changesRemote, value: obs.peek() }) : waitForSet;
-      if (waitFor) {
-        await when(waitFor);
+    if (!syncState2.isLoaded.peek()) {
+      await when(syncState2.isLoaded);
+      const pending = localState.pendingChanges;
+      if (pending) {
+        changesRemote.forEach((change) => {
+          const key = change.pathStr;
+          const pendingAtPath = pending[key];
+          if (!isNullOrUndefined(pendingAtPath)) {
+            const { p } = pendingAtPath;
+            change.prevAtPath = p;
+          }
+        });
       }
     }
-    let value = clone(obs.peek());
+    if (waitForSetParam) {
+      await waitForSet(waitForSetParam, changesRemote, obs$.peek());
+    }
+    let value = clone(obs$.peek());
     const transformSave = (_a = syncOptions == null ? void 0 : syncOptions.transform) == null ? void 0 : _a.save;
     if (transformSave) {
       value = transformSave(value);
     }
-    onBeforeSet == null ? void 0 : onBeforeSet();
-    let savedPromise = pluginSync.set({
-      value$: obs,
-      syncState,
-      options: syncOptions,
-      changes: changesRemote,
-      value,
-      valuePrevious: previous
-    });
-    if (isPromise(savedPromise)) {
-      savedPromise = savedPromise.catch((err) => onSetError == null ? void 0 : onSetError(err));
-    }
-    const saved = await savedPromise;
-    if (saved !== void 0) {
-      const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
-      const { changes, lastSync } = saved;
-      if (pathStrs.length > 0) {
-        let transformedChanges = void 0;
-        const metadata = {};
-        if (saveLocal) {
-          const pendingMetadata = (_b = pluginPersist.getMetadata(table, configLocal)) == null ? void 0 : _b.pending;
-          const pending = localState.pendingChanges;
-          for (let i = 0; i < pathStrs.length; i++) {
-            const pathStr = pathStrs[i];
-            if (pendingMetadata == null ? void 0 : pendingMetadata[pathStr]) {
-              delete pendingMetadata[pathStr];
-              metadata.pending = pendingMetadata;
+    state$.numPendingSets.set((v) => (v || 0) + 1);
+    state$.isSetting.set(true);
+    const beforeSetParams = {
+      cancel: false
+    };
+    onBeforeSet == null ? void 0 : onBeforeSet(beforeSetParams);
+    if (!beforeSetParams.cancel) {
+      let updateResult = void 0;
+      let errorHandled = false;
+      const onError = (error, retryParams) => {
+        var _a2;
+        state$.error.set(error);
+        if (!errorHandled) {
+          (_a2 = syncOptions.onError) == null ? void 0 : _a2.call(syncOptions, error, {
+            setParams,
+            source: "set",
+            value$: obs$,
+            retryParams
+          });
+        }
+        errorHandled = true;
+      };
+      const setParams = {
+        node,
+        value$: obs$,
+        changes: changesRemote,
+        value,
+        onError,
+        update: (params) => {
+          if (updateResult) {
+            const { value: value2, lastSync, mode } = params;
+            updateResult = {
+              lastSync: Math.max(updateResult.lastSync || 0, lastSync || 0),
+              value: deepMerge(updateResult.value, value2),
+              mode
+            };
+          } else {
+            updateResult = params;
+          }
+        },
+        refresh: syncState2.sync,
+        retryNum: 0,
+        cancelRetry: false
+      };
+      const savedPromise = runWithRetry(
+        setParams,
+        syncOptions.retry,
+        async () => {
+          return syncOptions.set(setParams);
+        },
+        onError
+      );
+      let didError = false;
+      if (isPromise$1(savedPromise)) {
+        await savedPromise.catch((error) => {
+          didError = true;
+          if (!syncOptions.retry) {
+            onError(error);
+          }
+        });
+      }
+      if (!didError) {
+        const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
+        const { value: changes, lastSync } = updateResult || {};
+        if (pathStrs.length > 0) {
+          let transformedChanges = void 0;
+          const metadata = {};
+          if (saveLocal) {
+            const pendingMetadata = (_b = pluginPersist.getMetadata(table, configLocal)) == null ? void 0 : _b.pending;
+            const pending = localState.pendingChanges;
+            for (let i = 0; i < pathStrs.length; i++) {
+              const pathStr = pathStrs[i];
+              if (pendingMetadata == null ? void 0 : pendingMetadata[pathStr]) {
+                delete pendingMetadata[pathStr];
+                metadata.pending = pendingMetadata;
+              }
+              if (pending == null ? void 0 : pending[pathStr]) {
+                delete pending[pathStr];
+              }
             }
-            if (pending == null ? void 0 : pending[pathStr]) {
-              delete pending[pathStr];
+            if (lastSync) {
+              metadata.lastSync = lastSync;
             }
           }
-          if (lastSync) {
-            metadata.lastSync = lastSync;
+          if (changes && !isEmpty(changes)) {
+            transformedChanges = transformLoadData(changes, syncOptions, false, "set");
           }
-        }
-        if (changes && !isEmpty(changes)) {
-          transformedChanges = transformLoadData(changes, syncOptions, false, "set");
-        }
-        if (transformedChanges !== void 0) {
-          if (isPromise(transformedChanges)) {
-            transformedChanges = await transformedChanges;
+          if (transformedChanges !== void 0) {
+            if (isPromise$1(transformedChanges)) {
+              transformedChanges = await transformedChanges;
+            }
+            onChangeRemote(() => mergeIntoObservable(obs$, transformedChanges));
           }
-          onChangeRemote(() => mergeIntoObservable(obs, transformedChanges));
-        }
-        if (saveLocal) {
-          if (shouldSaveMetadata && !isEmpty(metadata)) {
-            updateMetadata(obs, localState, syncState, syncOptions, metadata);
+          if (saveLocal) {
+            if (shouldSaveMetadata && !isEmpty(metadata)) {
+              updateMetadata(obs$, localState, syncState2, syncOptions, metadata);
+            }
           }
         }
+        state$.numPendingSets.set((v) => v - 1);
+        state$.isSetting.set(state$.numPendingSets.peek() > 0);
         onAfterSet == null ? void 0 : onAfterSet();
       }
     }
   }
 }
-function onObsChange(value$, syncState, localState, syncOptions, { changes, loading, remote, getPrevious }) {
-  if (!loading) {
-    const inRemoteChange = remote;
+function onObsChange(value$, syncState2, localState, syncOptions, { changes, isFromPersist, isFromSync, getPrevious }) {
+  if (!isFromPersist) {
+    const inRemoteChange = isFromSync;
     const isApplyingPending = localState.isApplyingPending;
     _queuedChanges.push({
       value$,
-      syncState,
+      syncState: syncState2,
       localState,
       syncOptions,
       changes,
@@ -602,24 +708,27 @@ function onObsChange(value$, syncState, localState, syncOptions, { changes, load
     }
   }
 }
-async function loadLocal(value$, syncOptions, syncState, localState) {
+async function loadLocal(value$, syncOptions, syncState$, localState) {
   var _a, _b, _c;
   const { persist } = syncOptions;
   const node = getNode(value$);
   const nodeValue = getNodeValue(getNode(node.state));
+  const syncStateValue = syncState$.peek();
+  const prevResetPersistence = nodeValue.resetPersistence;
   if (persist == null ? void 0 : persist.name) {
     const PersistPlugin = persist.plugin || ((_a = observableSyncConfiguration.persist) == null ? void 0 : _a.plugin);
     const { table, config } = parseLocalConfig(persist);
+    syncStateValue.numPendingLocalLoads = (syncStateValue.numPendingLocalLoads || 0) + 1;
     if (!PersistPlugin) {
       throw new Error("Local persist is not configured");
     }
     if (!mapSyncPlugins.has(PersistPlugin)) {
-      const persistPlugin2 = new PersistPlugin();
+      const persistPlugin2 = isFunction(PersistPlugin) ? new PersistPlugin() : PersistPlugin;
       const mapValue = { plugin: persistPlugin2, initialized: observable(false) };
       mapSyncPlugins.set(PersistPlugin, mapValue);
       if (persistPlugin2.initialize) {
         const initializePromise = (_c = persistPlugin2.initialize) == null ? void 0 : _c.call(persistPlugin2, ((_b = observableSyncConfiguration) == null ? void 0 : _b.persist) || {});
-        if (isPromise(initializePromise)) {
+        if (isPromise$1(initializePromise)) {
           await initializePromise;
         }
       }
@@ -643,14 +752,14 @@ async function loadLocal(value$, syncOptions, syncState, localState) {
     if (metadata) {
       metadatas.set(value$, metadata);
       localState.pendingChanges = metadata.pending;
-      syncState.assign({
+      syncState$.assign({
         lastSync: metadata.lastSync
       });
     }
     if (value !== void 0) {
       const { transform } = config;
       value = transformLoadData(value, { transform }, true, "get");
-      if (isPromise(value)) {
+      if (isPromise$1(value)) {
         value = await value;
       }
       internal.globalState.isLoadingLocal = true;
@@ -661,15 +770,19 @@ async function loadLocal(value$, syncOptions, syncState, localState) {
       }
       internal.globalState.isLoadingLocal = false;
     }
-    nodeValue.clearPersist = () => Promise.all([
-      persistPlugin.deleteTable(table, config),
-      persistPlugin.deleteMetadata(table, config)
-    ]);
+    syncStateValue.numPendingLocalLoads--;
+    nodeValue.resetPersistence = () => Promise.all(
+      [
+        prevResetPersistence,
+        persistPlugin.deleteTable(table, config),
+        persistPlugin.deleteMetadata(table, config)
+      ].filter(Boolean)
+    );
   } else {
-    nodeValue.clearPersist = () => {
-    };
+    nodeValue.resetPersistence = () => prevResetPersistence == null ? void 0 : prevResetPersistence();
   }
-  syncState.isPersistLoaded.set(true);
+  nodeValue.clearPersist = nodeValue.resetPersistence;
+  syncState$.isPersistLoaded.set(!(syncStateValue.numPendingLocalLoads > 0));
 }
 function syncObservable(obs$, syncOptionsOrSynced) {
   let syncOptions = syncOptionsOrSynced;
@@ -680,7 +793,7 @@ function syncObservable(obs$, syncOptionsOrSynced) {
   if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && (!obs$ || !node)) {
     throw new Error("[legend-state] syncObservable called with undefined observable");
   }
-  syncOptions = mergeIntoObservable(
+  syncOptions = deepMerge(
     {
       syncMode: "auto"
     },
@@ -689,24 +802,54 @@ function syncObservable(obs$, syncOptionsOrSynced) {
   );
   const localState = {};
   let sync;
-  const syncState = node.state = observable({
-    isPersistLoaded: false,
-    isLoaded: !syncOptions.get,
-    isPersistEnabled: true,
-    isSyncEnabled: true,
-    clearPersist: void 0,
-    sync: () => Promise.resolve(),
-    getPendingChanges: () => localState.pendingChanges
-  });
-  loadLocal(obs$, syncOptions, syncState, localState);
-  localState.pluginSync = syncObservableAdapter(syncOptions);
+  const syncState$ = syncState(obs$);
+  const syncStateValue = getNodeValue(getNode(syncState$));
+  allSyncStates.set(syncState$, node);
+  syncStateValue.getPendingChanges = () => localState.pendingChanges;
+  let errorHandled = false;
+  const onGetError = (error, params) => {
+    var _a;
+    syncState$.error.set(error);
+    if (!errorHandled) {
+      (_a = syncOptions.onError) == null ? void 0 : _a.call(syncOptions, error, { ...params, value$: obs$ });
+    }
+    errorHandled = true;
+  };
+  loadLocal(obs$, syncOptions, syncState$, localState);
+  let isWaitingForLoad = !!syncOptions.get;
+  if (isWaitingForLoad) {
+    syncStateValue.numPendingRemoteLoads = (syncStateValue.numPendingRemoteLoads || 0) + 1;
+  }
+  syncState$.isLoaded.set(!syncState$.numPendingRemoteLoads.peek());
+  let isSynced = false;
+  let isSubscribed = false;
+  let unsubscribe = void 0;
+  const applyPending = (pending) => {
+    if (pending && !isEmpty(pending)) {
+      localState.isApplyingPending = true;
+      const keys = Object.keys(pending);
+      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 value = getNodeValue(node);
+      onObsChange(obs$, syncState$, localState, syncOptions, {
+        value,
+        isFromPersist: false,
+        isFromSync: false,
+        getPrevious: createPreviousHandler(value, changes),
+        changes
+      });
+      localState.isApplyingPending = false;
+    }
+  };
   if (syncOptions.get) {
-    let isSynced = false;
-    let isSubscribed = false;
-    let unsubscribe = void 0;
     sync = async () => {
-      var _a, _b;
-      if (isSynced && shouldIgnoreUnobserved(node, sync)) {
+      var _a;
+      if (isSynced && (!getNodeValue(getNode(syncState$)).isSyncEnabled || shouldIgnoreUnobserved(node, sync))) {
         if (unsubscribe) {
           isSubscribed = false;
           unsubscribe();
@@ -716,14 +859,16 @@ function syncObservable(obs$, syncOptionsOrSynced) {
       }
       const lastSync = (_a = metadatas.get(obs$)) == null ? void 0 : _a.lastSync;
       const pending = localState.pendingChanges;
-      const get = (_b = localState.pluginSync.get) == null ? void 0 : _b.bind(localState.pluginSync);
+      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 (isPromise(value)) {
+              if (isPromise$1(value)) {
                 value = await value;
               }
               const pending2 = localState.pendingChanges;
@@ -731,9 +876,11 @@ function syncObservable(obs$, syncOptionsOrSynced) {
               if (pending2) {
                 let didChangeMetadata = false;
                 Object.keys(pending2).forEach((key) => {
-                  const p = key.split("/").filter((p2) => p2 !== "");
+                  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 (isObject(value) && isObject(v)) {
                       Object.assign(value, v);
                     } else {
@@ -746,6 +893,8 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                       delete pending2[key];
                       didChangeMetadata = true;
                     } else {
+                      const oldValue = clone(value);
+                      pending2[key].p = getValueAtPath(oldValue, p);
                       value = setAtPath(
                         value,
                         p,
@@ -765,18 +914,27 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                     }
                   }
                 });
-                if (didChangeMetadata) {
-                  updateMetadata(obs$, localState, syncState, syncOptions, {
+                if (didChangeMetadata && syncOptions.persist) {
+                  updateMetadata(obs$, localState, syncState$, syncOptions, {
                     pending: pending2
                   });
                 }
               }
               onChangeRemote(() => {
-                if (mode === "assign" && isObject(value)) {
+                if (isPlainObject(value)) {
+                  value = ObservableHint.plain(value);
+                }
+                if (mode === "assign") {
                   obs$.assign(value);
-                } else if (mode === "append" && isArray(value)) {
+                } else if (mode === "append") {
+                  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !isArray(value)) {
+                    console.error("[legend-state] mode:append expects the value to be an array");
+                  }
                   obs$.push(...value);
-                } else if (mode === "prepend" && isArray(value)) {
+                } else if (mode === "prepend") {
+                  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && !isArray(value)) {
+                    console.error("[legend-state] mode:prepend expects the value to be an array");
+                  }
                   obs$.splice(0, 0, ...value);
                 } else if (mode === "merge") {
                   mergeIntoObservable(obs$, value);
@@ -786,78 +944,180 @@ function syncObservable(obs$, syncOptionsOrSynced) {
               });
             }
             if (lastSync2 && syncOptions.persist) {
-              updateMetadata(obs$, localState, syncState, syncOptions, {
+              updateMetadata(obs$, localState, syncState$, syncOptions, {
                 lastSync: lastSync2
               });
             }
           };
-          get({
-            state: syncState,
+          if (node.activationState) {
+            node.activationState.onChange = onChange;
+          }
+          if (!isSubscribed && syncOptions.subscribe) {
+            const subscribe = syncOptions.subscribe;
+            isSubscribed = true;
+            const doSubscribe = () => {
+              const subscribeParams = {
+                node,
+                value$: obs$,
+                lastSync,
+                update: (params) => {
+                  when(syncState$.isLoaded, () => {
+                    when(waitFor || true, () => {
+                      params.mode || (params.mode = syncOptions.mode || "merge");
+                      onChange(params);
+                    });
+                  });
+                },
+                refresh: () => when(syncState$.isLoaded, sync),
+                onError: (error) => onGetError(error, { source: "subscribe", subscribeParams })
+              };
+              unsubscribe = subscribe(subscribeParams);
+            };
+            if (waitFor) {
+              whenReady(waitFor, doSubscribe);
+            } else {
+              doSubscribe();
+            }
+          }
+          const existingValue = getNodeValue(node);
+          const onError = (error) => onGetError(error, { getParams, source: "get" });
+          const getParams = {
+            node,
             value$: obs$,
+            value: isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked]) ? void 0 : existingValue,
+            mode: syncOptions.mode,
+            refresh: sync,
             options: syncOptions,
             lastSync,
-            dateModified: lastSync,
-            onError: (error) => {
-              var _a2;
-              (_a2 = syncOptions.onGetError) == null ? void 0 : _a2.call(syncOptions, error);
-            },
-            onGet: () => {
-              node.state.assign({
-                isLoaded: true,
-                error: void 0
+            updateLastSync: (lastSync2) => getParams.lastSync = lastSync2,
+            onError,
+            retryNum: 0,
+            cancelRetry: false
+          };
+          let modeBeforeReset = void 0;
+          const beforeGetParams = {
+            value: getParams.value,
+            lastSync,
+            pendingChanges: pending && !isEmpty(pending) ? pending : void 0,
+            clearPendingChanges: async () => {
+              localState.pendingChanges = {};
+              await updateMetadataImmediate(obs$, localState, syncState$, syncOptions, {
+                pending: localState.pendingChanges
               });
             },
-            onChange
-          });
-          if (!isSubscribed && syncOptions.subscribe) {
-            isSubscribed = true;
-            unsubscribe = syncOptions.subscribe({
-              node,
-              value$: obs$,
-              update: (params) => {
-                when(node.state.isLoaded, () => {
-                  params.mode || (params.mode = syncOptions.mode || "merge");
-                  onChange(params);
-                });
-              },
-              refresh: () => when(node.state.isLoaded, sync)
+            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 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
+              });
+            };
+            if (isPromise$1(got)) {
+              got.then(handle).catch(onError);
+            } else {
+              handle(got);
+            }
           }
         };
-        runGet();
+        if (waitFor) {
+          whenReady(waitFor, () => trackSelector(runGet, sync));
+        } else {
+          trackSelector(runGet, sync);
+        }
       } else {
-        node.state.assign({
+        syncState$.assign({
           isLoaded: true,
           error: void 0
         });
       }
       if (!isSynced) {
         isSynced = true;
-        await when(() => syncState.isLoaded.get() || syncOptions.allowSetIfGetError && syncState.error.get());
-        if (pending && !isEmpty(pending)) {
-          localState.isApplyingPending = true;
-          const keys = Object.keys(pending);
-          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 value = getNodeValue(node);
-          onObsChange(obs$, syncState, localState, syncOptions, {
-            value,
-            loading: false,
-            remote: false,
-            getPrevious: createPreviousHandler(value, changes),
-            changes
-          });
-          localState.isApplyingPending = false;
-        }
+        await when(syncState$.isLoaded);
+        applyPending(pending);
       }
     };
-    syncState.assign({ sync });
+    syncStateValue.sync = sync;
+  } else {
+    if (!isSynced) {
+      applyPending(localState.pendingChanges);
+    }
   }
+  syncStateValue.reset = async () => {
+    const wasPersistEnabled = syncStateValue.isPersistEnabled;
+    const wasSyncEnabled = syncStateValue.isSyncEnabled;
+    const metadata = metadatas.get(obs$);
+    if (metadata) {
+      Object.assign(metadata, { lastSync: void 0, pending: void 0 });
+    }
+    Object.assign(syncStateValue, {
+      isPersistEnabled: false,
+      isSyncEnabled: false,
+      lastSync: void 0,
+      numPendingGets: 0,
+      isLoaded: false,
+      isGetting: false,
+      isSetting: false,
+      numPendingSets: 0,
+      syncCount: 0
+    });
+    isSynced = false;
+    isSubscribed = false;
+    unsubscribe == null ? void 0 : unsubscribe();
+    unsubscribe = void 0;
+    const promise = syncStateValue.resetPersistence();
+    onChangeRemote(() => {
+      var _a;
+      obs$.set((_a = syncOptions.initial) != null ? _a : void 0);
+    });
+    syncState$.isLoaded.set(false);
+    syncStateValue.isPersistEnabled = wasPersistEnabled;
+    syncStateValue.isSyncEnabled = wasSyncEnabled;
+    node.dirtyFn = sync;
+    await promise;
+  };
   const onAllPersistLoaded = () => {
     var _a, _b;
     let parentNode = node;
@@ -875,77 +1135,27 @@ function syncObservable(obs$, syncOptionsOrSynced) {
     }
     if ((syncOptions == null ? void 0 : syncOptions.set) || (syncOptions == null ? void 0 : syncOptions.persist)) {
       obs$.onChange(
-        onObsChange.bind(this, obs$, syncState, localState, syncOptions)
+        onObsChange.bind(this, obs$, syncState$, localState, syncOptions)
       );
     }
   });
-  return syncState;
+  return syncState$;
 }
-var { getProxy, globalState: globalState2, runWithRetry, symbolLinked: symbolLinked2, setNodeValue, getNodeValue: getNodeValue2 } = internal;
+var { getProxy, globalState: globalState2, setNodeValue, getNodeValue: getNodeValue2 } = internal;
 function enableActivateSyncedNode() {
   globalState2.activateSyncedNode = function activateSyncedNode(node, newValue) {
     const obs$ = getProxy(node);
     if (node.activationState) {
-      const { get, initial, set, retry } = node.activationState;
-      let onChange = void 0;
-      const pluginRemote = {};
+      const {
+        get: getOrig,
+        initial,
+        set,
+        onChange
+      } = node.activationState;
       let promiseReturn = void 0;
-      let syncState;
-      const refresh = () => syncState == null ? void 0 : syncState.sync();
-      if (get) {
-        pluginRemote.get = (params) => {
-          var _a;
-          onChange = params.onChange;
-          const updateLastSync = (lastSync) => params.lastSync = lastSync;
-          const existingValue = getNodeValue2(node);
-          const value = runWithRetry(node, { attemptNum: 0, retry: retry || ((_a = params.options) == null ? void 0 : _a.retry) }, () => {
-            const paramsToGet = {
-              value: isFunction(existingValue) || (existingValue == null ? void 0 : existingValue[symbolLinked2]) ? void 0 : existingValue,
-              lastSync: params.lastSync,
-              updateLastSync,
-              mode: params.mode,
-              refresh
-            };
-            const ret = get(paramsToGet);
-            params.mode = paramsToGet.mode;
-            return ret;
-          });
-          promiseReturn = value;
-          return value;
-        };
-      }
-      if (set) {
-        pluginRemote.set = async (params) => {
-          var _a, _b;
-          if ((_a = node.state) == null ? void 0 : _a.isLoaded.get()) {
-            const retryAttempts = { attemptNum: 0, retry: retry || ((_b = params.options) == null ? void 0 : _b.retry) };
-            return runWithRetry(node, retryAttempts, async (retryEvent) => {
-              let changes = {};
-              let maxModified = 0;
-              if (!node.state.isLoaded.peek()) {
-                await whenReady(node.state.isLoaded);
-              }
-              const cancelRetry = () => {
-                retryEvent.cancel = true;
-              };
-              await set({
-                ...params,
-                node,
-                update: (params2) => {
-                  const { value, lastSync } = params2;
-                  maxModified = Math.max(lastSync || 0, maxModified);
-                  changes = mergeIntoObservable(changes, value);
-                },
-                retryNum: retryAttempts.attemptNum,
-                cancelRetry,
-                refresh,
-                fromSubscribe: false
-              });
-              return { changes, lastSync: maxModified || void 0 };
-            });
-          }
-        };
-      }
+      const get = getOrig ? (params) => {
+        return promiseReturn = getOrig(params);
+      } : void 0;
       const nodeVal = getNodeValue2(node);
       if (promiseReturn !== void 0) {
         newValue = promiseReturn;
@@ -955,13 +1165,13 @@ function enableActivateSyncedNode() {
         newValue = initial;
       }
       setNodeValue(node, promiseReturn ? void 0 : newValue);
-      syncState = syncObservable(obs$, { ...node.activationState, ...pluginRemote });
+      syncObservable(obs$, { ...node.activationState, get, set });
       return { update: onChange, value: newValue };
     } else {
       let update = void 0;
       const get = async (params) => {
         update = params.refresh;
-        if (isPromise(newValue)) {
+        if (isPromise$1(newValue)) {
           try {
             newValue = await newValue;
           } catch (e) {
@@ -992,13 +1202,20 @@ function installPersistActivateNode() {
     didInstall = true;
   }
 }
+var { deepMerge: deepMerge2 } = internal;
+function configureSynced(fnOrOrigOptions, origOptions) {
+  const fn = origOptions ? fnOrOrigOptions : synced;
+  origOptions = origOptions != null ? origOptions : fnOrOrigOptions;
+  return (options) => {
+    const merged = deepMerge2(origOptions, options);
+    return fn(merged);
+  };
+}
 
 // sync.ts
-function isInRemoteChange() {
-  return internal.globalState.isLoadingRemote;
-}
-var internal3 = {
-  observableSyncConfiguration
+var internal4 = {
+  observableSyncConfiguration,
+  waitForSet
 };
 
-export { combineTransforms, configureObservableSync, deepEqual, diffObjects, internal3 as internal, isInRemoteChange, mapSyncPlugins, onChangeRemote, removeNullUndefined, syncObservable, synced, transformStringifyDates, transformStringifyKeys };
+export { combineTransforms, configureObservableSync, configureSynced, deepEqual, diffObjects, internal4 as internal, mapSyncPlugins, onChangeRemote, removeNullUndefined, syncObservable, synced, transformStringifyDates, transformStringifyKeys };