@legendapp/state 3.0.0-alpha.3 → 3.0.0-alpha.31

package/sync.js

@@ -2,8 +2,6 @@
 
 var state = require('@legendapp/state');
 
-// sync.ts
-
 // src/sync/configureObservableSync.ts
 var observableSyncConfiguration = {};
 function configureObservableSync(options) {
@@ -139,34 +137,80 @@ function transformStringifyDates(...args) {
     }
   };
 }
-function syncObservableAdapter({ get, set }) {
-  const ret = {};
-  if (get) {
-    ret.get = async (params) => {
-      try {
-        let value = get(params);
-        if (state.isPromise(value)) {
-          value = await value;
-        }
-        params.onChange({
-          value,
-          lastSync: params.lastSync,
-          mode: params.mode
+
+// 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) {
+  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);
+          }
+          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;
+            }
+          }
         });
-        params.onGet();
-      } catch (e) {
-      }
-    };
+      };
+      run();
+    });
   }
-  if (set) {
-    ret.set = set;
+  return value;
+}
+async function waitForSet(waitForSet2, changes, value, params = {}) {
+  const waitFn = state.isFunction(waitForSet2) ? waitForSet2({ changes, value, ...params }) : waitForSet2;
+  if (waitFn) {
+    await state.when(waitFn);
   }
-  return ret;
 }
 
 // src/sync/syncObservable.ts
-var { createPreviousHandler, clone, getValueAtPath, globalState, symbolLinked, getNode, getNodeValue } = state.internal;
+var { clone, deepMerge, getNode, getNodeValue, getValueAtPath, globalState, symbolLinked, createPreviousHandler } = state.internal;
 var mapSyncPlugins = /* @__PURE__ */ new WeakMap();
+var allSyncStates = /* @__PURE__ */ new Map();
 var metadatas = /* @__PURE__ */ new WeakMap();
 var promisesLocalSaves = /* @__PURE__ */ new Set();
 function parseLocalConfig(config) {
@@ -183,13 +227,19 @@ function onChangeRemote(cb) {
   globalState.isLoadingRemote = false;
   state.endBatch(true);
 }
-function transformSaveData(value, path, pathTypes, { transform }) {
+async function transformSaveData(value, path, pathTypes, { transform }) {
   if (transform == null ? void 0 : transform.save) {
     const constructed = state.constructObjectWithPath(path, pathTypes, value);
-    const saved = transform.save(constructed);
-    value = state.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)) {
@@ -197,7 +247,7 @@ 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);
@@ -212,17 +262,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
   );
 }
@@ -250,26 +300,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()));
 }
@@ -315,15 +360,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
@@ -356,13 +399,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("/")
               });
             })
           );
@@ -378,22 +421,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
@@ -423,20 +463,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);
                   state.setAtPath(
                     localState.pendingChanges[pathParent].v,
@@ -458,12 +498,11 @@ async function prepChangeRemote(queuedChange) {
                 localState.pendingChanges[pathStr].v = valueAtPath;
               }
               changesRemote.push({
-                path,
+                path: pathTransformed,
                 pathTypes,
                 prevAtPath,
                 valueAtPath: valueTransformed,
-                pathStr,
-                valuePrevious
+                pathStr
               });
             })
           );
@@ -481,24 +520,27 @@ 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 { table, config: configLocal } = parseLocalConfig(persist);
-  const shouldSaveMetadata = persist == null ? void 0 : persist.retrySync;
-  if (saveRemote && shouldSaveMetadata) {
-    await updateMetadataImmediate(obs, localState, syncState, syncOptions, {
-      pending: localState.pendingChanges
-    });
-  }
-  if (changesLocal.length > 0) {
-    let promiseSet = pluginPersist.set(table, changesLocal, configLocal);
-    if (promiseSet) {
-      promiseSet = promiseSet.then(() => {
-        promisesLocalSaves.delete(promiseSet);
+  const saveLocal = !!(persist == null ? void 0 : persist.name);
+  if (saveLocal) {
+    const { table, config: configLocal } = parseLocalConfig(persist);
+    const shouldSaveMetadata = persist == null ? void 0 : persist.retrySync;
+    if (saveRemote && shouldSaveMetadata) {
+      await updateMetadataImmediate(obs, localState, syncState2, syncOptions, {
+        pending: localState.pendingChanges
       });
-      promisesLocalSaves.add(promiseSet);
-      await promiseSet;
+    }
+    if (changesLocal.length > 0) {
+      let promiseSet = pluginPersist.set(table, changesLocal, configLocal);
+      if (promiseSet) {
+        promiseSet = promiseSet.then(() => {
+          promisesLocalSaves.delete(promiseSet);
+        });
+        promisesLocalSaves.add(promiseSet);
+        await promiseSet;
+      }
     }
   }
 }
@@ -507,47 +549,96 @@ 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 state.when(() => syncState.isLoaded.get() || allowSetIfGetError && syncState.error.get());
-    if (waitForSet) {
-      const waitFor = state.isFunction(waitForSet) ? waitForSet({ changes: changesRemote, value: obs.peek() }) : waitForSet;
-      if (waitFor) {
-        await state.when(waitFor);
+    if (!syncState2.isLoaded.peek()) {
+      await state.when(syncState2.isLoaded);
+      const pending = localState.pendingChanges;
+      if (pending) {
+        changesRemote.forEach((change) => {
+          const key = change.pathStr;
+          const pendingAtPath = pending[key];
+          if (!state.isNullOrUndefined(pendingAtPath)) {
+            const { p } = pendingAtPath;
+            change.prevAtPath = p;
+          }
+        });
       }
     }
-    let value = 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(clone(value));
+      value = transformSave(value);
     }
+    state$.numPendingSets.set((v) => (v || 0) + 1);
+    state$.isSetting.set(true);
     onBeforeSet == null ? void 0 : onBeforeSet();
-    localState.numSavesOutstanding = (localState.numSavesOutstanding || 0) + 1;
-    let savedPromise = pluginSync.set({
-      value$: obs,
-      syncState,
-      options: syncOptions,
+    let updateResult = void 0;
+    const onError = (error) => {
+      var _a2;
+      state$.error.set(error);
+      (_a2 = syncOptions.onSetError) == null ? void 0 : _a2.call(syncOptions, error, {
+        setParams,
+        source: "set",
+        value$: obs$
+      });
+    };
+    const setParams = {
+      node,
+      value$: obs$,
       changes: changesRemote,
       value,
-      valuePrevious: previous
-    });
+      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
+    };
+    let savedPromise = runWithRetry(
+      setParams,
+      syncOptions.retry,
+      async () => {
+        return syncOptions.set(setParams);
+      },
+      onError
+    );
+    let didError = false;
     if (state.isPromise(savedPromise)) {
-      savedPromise = savedPromise.catch((err) => onSetError == null ? void 0 : onSetError(err));
+      savedPromise = savedPromise.catch((error) => {
+        didError = true;
+        onError(error);
+      });
+      await savedPromise;
     }
-    const saved = await savedPromise;
-    localState.numSavesOutstanding--;
-    if (saved !== void 0) {
+    if (!didError) {
       const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
-      const { changes, lastSync } = saved;
+      const { value: changes, lastSync } = updateResult || {};
       if (pathStrs.length > 0) {
         let transformedChanges = void 0;
         const metadata = {};
-        if (persist) {
+        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++) {
@@ -567,42 +658,31 @@ async function doChangeRemote(changeInfo) {
         if (changes && !state.isEmpty(changes)) {
           transformedChanges = transformLoadData(changes, syncOptions, false, "set");
         }
-        if (localState.numSavesOutstanding > 0) {
-          if (transformedChanges) {
-            if (!localState.pendingSaveResults) {
-              localState.pendingSaveResults = [];
-            }
-            localState.pendingSaveResults.push(transformedChanges);
+        if (transformedChanges !== void 0) {
+          if (state.isPromise(transformedChanges)) {
+            transformedChanges = await transformedChanges;
           }
-        } else {
-          let allChanges = [...localState.pendingSaveResults || [], transformedChanges].filter(
-            (v) => v !== void 0
-          );
-          if (allChanges.length > 0) {
-            if (allChanges.some((change) => state.isPromise(change))) {
-              allChanges = await Promise.all(allChanges);
-            }
-            onChangeRemote(() => state.mergeIntoObservable(obs, ...allChanges));
-          }
-          if (persist) {
-            if (shouldSaveMetadata && !state.isEmpty(metadata)) {
-              updateMetadata(obs, localState, syncState, syncOptions, metadata);
-            }
+          onChangeRemote(() => state.mergeIntoObservable(obs$, transformedChanges));
+        }
+        if (saveLocal) {
+          if (shouldSaveMetadata && !state.isEmpty(metadata)) {
+            updateMetadata(obs$, localState, syncState2, syncOptions, metadata);
           }
-          localState.pendingSaveResults = [];
         }
-        onAfterSet == null ? void 0 : onAfterSet();
       }
+      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,
@@ -615,13 +695,17 @@ 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;
-  if (persist) {
+  const node = getNode(value$);
+  const nodeValue = getNodeValue(getNode(node.state));
+  const syncStateValue = syncState$.peek();
+  const prevClearPersist = nodeValue.clearPersist;
+  if (persist == null ? void 0 : persist.name) {
     const PersistPlugin = persist.plugin || ((_a = observableSyncConfiguration.persist) == null ? void 0 : _a.plugin);
     const { table, config } = parseLocalConfig(persist);
-    const node = getNode(value$);
+    syncStateValue.numPendingLocalLoads = (syncStateValue.numPendingLocalLoads || 0) + 1;
     if (!PersistPlugin) {
       throw new Error("Local persist is not configured");
     }
@@ -655,7 +739,7 @@ async function loadLocal(value$, syncOptions, syncState, localState) {
     if (metadata) {
       metadatas.set(value$, metadata);
       localState.pendingChanges = metadata.pending;
-      syncState.assign({
+      syncState$.assign({
         lastSync: metadata.lastSync
       });
     }
@@ -673,12 +757,18 @@ async function loadLocal(value$, syncOptions, syncState, localState) {
       }
       state.internal.globalState.isLoadingLocal = false;
     }
-    getNodeValue(getNode(node.state)).clearPersist = () => Promise.all([
-      persistPlugin.deleteTable(table, config),
-      persistPlugin.deleteMetadata(table, config)
-    ]);
+    syncStateValue.numPendingLocalLoads--;
+    nodeValue.clearPersist = () => Promise.all(
+      [
+        prevClearPersist,
+        persistPlugin.deleteTable(table, config),
+        persistPlugin.deleteMetadata(table, config)
+      ].filter(Boolean)
+    );
+  } else {
+    nodeValue.clearPersist = () => prevClearPersist == null ? void 0 : prevClearPersist();
   }
-  syncState.isPersistLoaded.set(true);
+  syncState$.isPersistLoaded.set(!(syncStateValue.numPendingLocalLoads > 0));
 }
 function syncObservable(obs$, syncOptionsOrSynced) {
   let syncOptions = syncOptionsOrSynced;
@@ -689,7 +779,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 = state.mergeIntoObservable(
+  syncOptions = deepMerge(
     {
       syncMode: "auto"
     },
@@ -698,24 +788,50 @@ function syncObservable(obs$, syncOptionsOrSynced) {
   );
   const localState = {};
   let sync;
-  const syncState = node.state = 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$ = state.syncState(obs$);
+  const syncStateValue = getNodeValue(getNode(syncState$));
+  allSyncStates.set(syncState$, node);
+  syncStateValue.getPendingChanges = () => localState.pendingChanges;
+  const onGetError = (error, params) => {
+    var _a;
+    syncState$.error.set(error);
+    (_a = syncOptions.onGetError) == null ? void 0 : _a.call(syncOptions, error, { ...params, value$: obs$ });
+  };
+  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 && !state.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 && state.shouldIgnoreUnobserved(node, sync)) {
+      var _a;
+      if (isSynced && (!getNodeValue(getNode(syncState$)).isSyncEnabled || state.shouldIgnoreUnobserved(node, sync))) {
         if (unsubscribe) {
           isSubscribed = false;
           unsubscribe();
@@ -725,9 +841,11 @@ 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) {
@@ -740,9 +858,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 (state.isObject(value) && state.isObject(v)) {
                       Object.assign(value, v);
                     } else {
@@ -755,6 +875,8 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                       delete pending2[key];
                       didChangeMetadata = true;
                     } else {
+                      const oldValue = clone(value);
+                      pending2[key].p = getValueAtPath(oldValue, p);
                       value = state.setAtPath(
                         value,
                         p,
@@ -774,18 +896,24 @@ 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" && state.isObject(value)) {
+                if (mode === "assign") {
                   obs$.assign(value);
-                } else if (mode === "append" && state.isArray(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" && state.isArray(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);
@@ -795,78 +923,174 @@ 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) => {
+                  state.when(syncState$.isLoaded, () => {
+                    state.when(waitFor || true, () => {
+                      params.mode || (params.mode = syncOptions.mode || "merge");
+                      onChange(params);
+                    });
+                  });
+                },
+                refresh: () => state.when(syncState$.isLoaded, sync),
+                onError: (error) => onGetError(error, { source: "subscribe", subscribeParams })
+              };
+              unsubscribe = subscribe(subscribeParams);
+            };
+            if (waitFor) {
+              state.whenReady(waitFor, doSubscribe);
+            } else {
+              doSubscribe();
+            }
+          }
+          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,
-            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;
+          (_a2 = syncOptions.onBeforeGet) == null ? void 0 : _a2.call(syncOptions, {
+            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
               });
             },
-            onChange
+            resetCache: () => {
+              var _a3;
+              modeBeforeReset = getParams.mode;
+              getParams.mode = "set";
+              return (_a3 = syncStateValue.clearPersist) == null ? void 0 : _a3.call(syncStateValue);
+            }
           });
-          if (!isSubscribed && syncOptions.subscribe) {
-            isSubscribed = true;
-            unsubscribe = syncOptions.subscribe({
-              node,
-              value$: obs$,
-              update: (params) => {
-                state.when(node.state.isLoaded, () => {
-                  params.mode || (params.mode = syncOptions.mode || "merge");
-                  onChange(params);
-                });
-              },
-              refresh: () => state.when(node.state.isLoaded, sync)
+          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 (state.isPromise(got)) {
+            got.then(handle);
+          } else {
+            handle(got);
           }
         };
-        runGet();
+        if (waitFor) {
+          state.whenReady(waitFor, () => state.trackSelector(runGet, sync));
+        } else {
+          state.trackSelector(runGet, sync);
+        }
       } else {
-        node.state.assign({
+        syncState$.assign({
           isLoaded: true,
           error: void 0
         });
       }
       if (!isSynced) {
         isSynced = true;
-        await state.when(() => syncState.isLoaded.get() || syncOptions.allowSetIfGetError && syncState.error.get());
-        if (pending && !state.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 state.when(syncState$.isLoaded);
+        applyPending(pending);
       }
     };
-    syncState.assign({ sync });
+    syncStateValue.sync = sync;
+  } else {
+    if (!isSynced) {
+      applyPending(localState.pendingChanges);
+    }
   }
+  syncStateValue.reset = async () => {
+    var _a;
+    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.clearPersist();
+    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;
@@ -884,77 +1108,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 } = state.internal;
+var { getProxy, globalState: globalState2, setNodeValue, getNodeValue: getNodeValue2 } = state.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: state.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 state.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 = state.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;
@@ -964,7 +1138,7 @@ 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;
@@ -1001,21 +1175,28 @@ function installPersistActivateNode() {
     didInstall = true;
   }
 }
+var { deepMerge: deepMerge2 } = state.internal;
+function configureSynced(fnOrOrigOptions, origOptions) {
+  const fn = origOptions ? fnOrOrigOptions : void 0;
+  origOptions = origOptions != null ? origOptions : fnOrOrigOptions;
+  return (options) => {
+    const merged = deepMerge2(origOptions, options);
+    return fn ? fn(merged) : merged;
+  };
+}
 
 // sync.ts
-function isInRemoteChange() {
-  return state.internal.globalState.isLoadingRemote;
-}
-var internal3 = {
-  observableSyncConfiguration
+var internal4 = {
+  observableSyncConfiguration,
+  waitForSet
 };
 
 exports.combineTransforms = combineTransforms;
 exports.configureObservableSync = configureObservableSync;
+exports.configureSynced = configureSynced;
 exports.deepEqual = deepEqual;
 exports.diffObjects = diffObjects;
-exports.internal = internal3;
-exports.isInRemoteChange = isInRemoteChange;
+exports.internal = internal4;
 exports.mapSyncPlugins = mapSyncPlugins;
 exports.onChangeRemote = onChangeRemote;
 exports.removeNullUndefined = removeNullUndefined;