@legendapp/state 3.0.0-alpha.0 → 3.0.0-alpha.2

package/sync.js

@@ -2,1072 +2,1020 @@
 
 var state = require('@legendapp/state');
 
-const observableSyncConfiguration = {};
+// sync.ts
+
+// src/sync/configureObservableSync.ts
+var observableSyncConfiguration = {};
 function configureObservableSync(options) {
-    Object.assign(observableSyncConfiguration, options);
+  Object.assign(observableSyncConfiguration, options);
 }
-
 function removeNullUndefined(a, recursive) {
-    const out = {};
-    Object.keys(a).forEach((key) => {
-        if (a[key] !== null && a[key] !== undefined) {
-            out[key] = recursive && state.isObject(a[key]) ? removeNullUndefined(a[key]) : a[key];
-        }
-    });
-    return out;
+  const out = {};
+  Object.keys(a).forEach((key) => {
+    if (a[key] !== null && a[key] !== void 0) {
+      out[key] = recursive && state.isObject(a[key]) ? removeNullUndefined(a[key]) : a[key];
+    }
+  });
+  return out;
 }
 function diffObjects(obj1, obj2, deep = false) {
-    const diff = {};
-    if (!obj1)
-        return obj2 || diff;
-    if (!obj2)
-        return obj1 || diff;
-    const keys = new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
-    keys.forEach((key) => {
-        const o1 = obj1[key];
-        const o2 = obj2[key];
-        if (deep ? !deepEqual(o1, o2) : o1 !== o2) {
-            if (!state.isDate(o1) || !state.isDate(o2) || o1.getTime() !== o2.getTime()) {
-                diff[key] = o2;
-            }
-        }
-    });
-    return diff;
+  const diff = {};
+  if (!obj1)
+    return obj2 || diff;
+  if (!obj2)
+    return obj1 || diff;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
+  keys.forEach((key) => {
+    const o1 = obj1[key];
+    const o2 = obj2[key];
+    if (deep ? !deepEqual(o1, o2) : o1 !== o2) {
+      if (!state.isDate(o1) || !state.isDate(o2) || o1.getTime() !== o2.getTime()) {
+        diff[key] = o2;
+      }
+    }
+  });
+  return diff;
 }
 function deepEqual(a, b, ignoreFields, nullVsUndefined) {
-    if (a === b) {
-        return true;
-    }
-    if (state.isNullOrUndefined(a) !== state.isNullOrUndefined(b)) {
-        return false;
-    }
-    if (nullVsUndefined) {
-        a = removeNullUndefined(a, /*recursive*/ true);
-        b = removeNullUndefined(b, /*recursive*/ true);
-    }
-    const replacer = ignoreFields
-        ? (key, value) => (ignoreFields.includes(key) ? undefined : value)
-        : undefined;
-    return JSON.stringify(a, replacer) === JSON.stringify(b, replacer);
+  if (a === b) {
+    return true;
+  }
+  if (state.isNullOrUndefined(a) !== state.isNullOrUndefined(b)) {
+    return false;
+  }
+  if (nullVsUndefined) {
+    a = removeNullUndefined(
+      a,
+      /*recursive*/
+      true
+    );
+    b = removeNullUndefined(
+      b,
+      /*recursive*/
+      true
+    );
+  }
+  const replacer = ignoreFields ? (key, value) => ignoreFields.includes(key) ? void 0 : value : void 0;
+  return JSON.stringify(a, replacer) === JSON.stringify(b, replacer);
 }
 function combineTransforms(...transforms) {
-    return {
-        load: (value, method) => {
-            let inValue = value;
-            transforms.forEach((transform) => {
-                if (transform.load) {
-                    inValue = transform.load(inValue, method);
-                }
-            });
-            return inValue;
-        },
-        save: (value) => {
-            let outValue = value;
-            transforms.forEach((transform) => {
-                if (transform.save) {
-                    outValue = transform.save(outValue);
-                }
-            });
-            return outValue;
-        },
-    };
+  return {
+    load: (value, method) => {
+      let inValue = value;
+      transforms.forEach((transform) => {
+        if (transform.load) {
+          inValue = transform.load(inValue, method);
+        }
+      });
+      return inValue;
+    },
+    save: (value) => {
+      let outValue = value;
+      transforms.forEach((transform) => {
+        if (transform.save) {
+          outValue = transform.save(outValue);
+        }
+      });
+      return outValue;
+    }
+  };
 }
-const ISO8601 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
+var ISO8601 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
 function transformStringifyKeys(...keys) {
-    return {
-        load: (value) => {
-            keys.forEach((key) => {
-                const keyRemote = state.isObject(key) ? key.from : key;
-                const keyLocal = state.isObject(key) ? key.to : key;
-                const v = value[keyRemote];
-                if (!state.isNullOrUndefined(v)) {
-                    value[keyLocal] = state.isString(v) ? JSON.parse(v) : v;
-                }
-                if (keyLocal !== keyRemote) {
-                    delete value[keyRemote];
-                }
-            });
-            return value;
-        },
-        save: (value) => {
-            keys.forEach((key) => {
-                const keyRemote = state.isObject(key) ? key.from : key;
-                const keyLocal = state.isObject(key) ? key.to : key;
-                const v = value[keyLocal];
-                if (!state.isNullOrUndefined(v) && !state.isString(v)) {
-                    value[keyRemote] = JSON.stringify(v);
-                }
-                if (keyLocal !== keyRemote) {
-                    delete value[keyLocal];
-                }
-            });
-            return value;
-        },
-    };
+  return {
+    load: (value) => {
+      keys.forEach((key) => {
+        const keyRemote = state.isObject(key) ? key.from : key;
+        const keyLocal = state.isObject(key) ? key.to : key;
+        const v = value[keyRemote];
+        if (!state.isNullOrUndefined(v)) {
+          value[keyLocal] = state.isString(v) ? JSON.parse(v) : v;
+        }
+        if (keyLocal !== keyRemote) {
+          delete value[keyRemote];
+        }
+      });
+      return value;
+    },
+    save: (value) => {
+      keys.forEach((key) => {
+        const keyRemote = state.isObject(key) ? key.from : key;
+        const keyLocal = state.isObject(key) ? key.to : key;
+        const v = value[keyLocal];
+        if (!state.isNullOrUndefined(v) && !state.isString(v)) {
+          value[keyRemote] = JSON.stringify(v);
+        }
+        if (keyLocal !== keyRemote) {
+          delete value[keyLocal];
+        }
+      });
+      return value;
+    }
+  };
 }
 function transformStringifyDates(...args) {
-    return {
-        load: (value) => {
-            const keys = args.length > 0 ? args : Object.keys(value);
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i];
-                const keyValue = value[key];
-                if (state.isString(keyValue) && keyValue.match(ISO8601)) {
-                    value[key] = new Date(keyValue);
-                }
-            }
-            return value;
-        },
-        save: (value) => {
-            const keys = args.length > 0 ? args : Object.keys(value);
-            for (let i = 0; i < keys.length; i++) {
-                const key = keys[i];
-                const keyValue = value[key];
-                if (state.isDate(keyValue)) {
-                    value[key] = keyValue.toISOString();
-                }
-            }
-            return value;
-        },
-    };
+  return {
+    load: (value) => {
+      const keys = args.length > 0 ? args : Object.keys(value);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const keyValue = value[key];
+        if (state.isString(keyValue) && keyValue.match(ISO8601)) {
+          value[key] = new Date(keyValue);
+        }
+      }
+      return value;
+    },
+    save: (value) => {
+      const keys = args.length > 0 ? args : Object.keys(value);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const keyValue = value[key];
+        if (state.isDate(keyValue)) {
+          value[key] = keyValue.toISOString();
+        }
+      }
+      return value;
+    }
+  };
 }
-
 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,
-                });
-                params.onGet();
-                // eslint-disable-next-line no-empty
-            }
-            catch (_a) { }
+  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
         });
-    }
-    if (set) {
-        ret.set = set;
-    }
-    return ret;
+        params.onGet();
+      } catch (e) {
+      }
+    };
+  }
+  if (set) {
+    ret.set = set;
+  }
+  return ret;
 }
 
-const { createPreviousHandler, clone, getValueAtPath, globalState: globalState$1, symbolLinked: symbolLinked$1, getNode, getNodeValue: getNodeValue$1 } = state.internal;
-const mapSyncPlugins = new WeakMap();
-const metadatas = new WeakMap();
-const promisesLocalSaves = new Set();
+// src/sync/syncObservable.ts
+var { createPreviousHandler, clone, getValueAtPath, globalState, symbolLinked, getNode, getNodeValue } = state.internal;
+var mapSyncPlugins = /* @__PURE__ */ new WeakMap();
+var metadatas = /* @__PURE__ */ new WeakMap();
+var promisesLocalSaves = /* @__PURE__ */ new Set();
 function parseLocalConfig(config) {
-    return config
-        ? state.isString(config)
-            ? { table: config, config: { name: config } }
-            : { table: config.name, config }
-        : {};
+  return config ? state.isString(config) ? { table: config, config: { name: config } } : { table: config.name, config } : {};
 }
 function doInOrder(arg1, arg2) {
-    return state.isPromise(arg1) ? arg1.then(arg2) : arg2(arg1);
+  return state.isPromise(arg1) ? arg1.then(arg2) : arg2(arg1);
 }
 function onChangeRemote(cb) {
-    state.endBatch(true);
-    // Remote changes should only update local state
-    globalState$1.isLoadingRemote = true;
-    state.beginBatch();
-    cb();
-    // Reset isLoadingRemote before ending the batch so it doesn't
-    // apply to any side effects
-    globalState$1.isLoadingRemote = false;
-    state.endBatch(true);
+  state.endBatch(true);
+  globalState.isLoadingRemote = true;
+  state.beginBatch();
+  cb();
+  globalState.isLoadingRemote = false;
+  state.endBatch(true);
 }
 function transformSaveData(value, path, pathTypes, { transform }) {
-    if (transform === null || transform === void 0 ? void 0 : transform.save) {
-        const constructed = state.constructObjectWithPath(path, pathTypes, value);
-        const saved = transform.save(constructed);
-        value = state.deconstructObjectWithPath(path, pathTypes, saved);
-    }
-    return value;
+  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);
+  }
+  return value;
 }
 function transformLoadData(value, { transform }, doUserTransform, method) {
-    if (doUserTransform && (transform === null || transform === void 0 ? void 0 : transform.load)) {
-        value = transform.load(value, method);
-    }
-    return value;
+  if (doUserTransform && (transform == null ? void 0 : transform.load)) {
+    value = transform.load(value, method);
+  }
+  return value;
 }
 async function updateMetadataImmediate(value$, localState, syncState, syncOptions, newMetadata) {
-    const saves = Array.from(promisesLocalSaves);
-    if (saves.length > 0) {
-        await Promise.all(saves);
+  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 oldMetadata = metadatas.get(value$);
+  const { lastSync, pending } = newMetadata;
+  const needsUpdate = pending || lastSync && (!oldMetadata || lastSync !== oldMetadata.lastSync);
+  if (needsUpdate) {
+    const metadata = Object.assign({}, oldMetadata, newMetadata);
+    metadatas.set(value$, metadata);
+    if (pluginPersist) {
+      await pluginPersist.setMetadata(table, metadata, config);
     }
-    const { pluginPersist } = localState;
-    const { table, config } = parseLocalConfig(syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.persist);
-    // Save metadata
-    const oldMetadata = metadatas.get(value$);
-    const { lastSync, pending } = newMetadata;
-    const needsUpdate = pending || (lastSync && (!oldMetadata || lastSync !== oldMetadata.lastSync));
-    if (needsUpdate) {
-        const metadata = Object.assign({}, oldMetadata, newMetadata);
-        metadatas.set(value$, metadata);
-        if (pluginPersist) {
-            await pluginPersist.setMetadata(table, metadata, config);
-        }
-        if (lastSync) {
-            syncState.assign({
-                lastSync: lastSync,
-            });
-        }
+    if (lastSync) {
+      syncState.assign({
+        lastSync
+      });
     }
+  }
 }
 function updateMetadata(value$, localState, syncState, syncOptions, newMetadata) {
-    if (localState.timeoutSaveMetadata) {
-        clearTimeout(localState.timeoutSaveMetadata);
-    }
-    localState.timeoutSaveMetadata = setTimeout(() => updateMetadataImmediate(value$, localState, syncState, syncOptions, newMetadata), 0);
+  if (localState.timeoutSaveMetadata) {
+    clearTimeout(localState.timeoutSaveMetadata);
+  }
+  localState.timeoutSaveMetadata = setTimeout(
+    () => updateMetadataImmediate(value$, localState, syncState, syncOptions, newMetadata),
+    0
+  );
 }
-let _queuedChanges = [];
-const _queuedRemoteChanges = new Map();
-const _queuedRemoteChangesTimeouts = new Map();
+var _queuedChanges = [];
+var _queuedRemoteChanges = /* @__PURE__ */ new Map();
+var _queuedRemoteChangesTimeouts = /* @__PURE__ */ new Map();
 function mergeChanges(changes) {
-    const changesByPath = new Map();
-    const changesOut = [];
-    // TODO: This could be even more robust by going deeper into paths like the firebase plugin's _updatePendingSave
-    for (let i = 0; i < changes.length; i++) {
-        const change = changes[i];
-        const pathStr = change.path.join('/');
-        const existing = changesByPath.get(pathStr);
-        if (existing) {
-            // If setting a value back to what it was, no need to save it
-            if (change.valueAtPath === existing.prevAtPath) {
-                changesOut.splice(changesOut.indexOf(change), 1);
-            }
-            else {
-                existing.valueAtPath = change.valueAtPath;
-            }
-        }
-        else {
-            changesByPath.set(pathStr, change);
-            changesOut.push(change);
-        }
+  const changesByPath = /* @__PURE__ */ new Map();
+  const changesOut = [];
+  for (let i = 0; i < changes.length; i++) {
+    const change = changes[i];
+    const pathStr = change.path.join("/");
+    const existing = changesByPath.get(pathStr);
+    if (existing) {
+      if (change.valueAtPath === existing.prevAtPath) {
+        changesOut.splice(changesOut.indexOf(change), 1);
+      } else {
+        existing.valueAtPath = change.valueAtPath;
+      }
+    } else {
+      changesByPath.set(pathStr, change);
+      changesOut.push(change);
     }
-    return changesOut;
+  }
+  return changesOut;
 }
 function mergeQueuedChanges(allChanges) {
-    const changesByObsRemote = new Map();
-    const changesByObsLocal = new Map();
-    const previousByObs = new Map();
-    const outRemote = new Map();
-    const outLocal = new Map();
-    for (let i = 0; i < allChanges.length; i++) {
-        const value = allChanges[i];
-        const { value$: obs, changes, inRemoteChange, getPrevious } = value;
-        const targetMap = inRemoteChange ? outRemote : outLocal;
-        const changesMap = inRemoteChange ? changesByObsRemote : changesByObsLocal;
-        const existing = changesMap.get(obs);
-        const newChanges = existing ? [...existing, ...changes] : changes;
-        const merged = mergeChanges(newChanges);
-        changesMap.set(obs, merged);
-        value.changes = merged;
-        if (!previousByObs.has(obs)) {
-            previousByObs.set(obs, getPrevious());
-        }
-        value.valuePrevious = previousByObs.get(obs);
-        targetMap.set(obs, value);
+  const changesByObsRemote = /* @__PURE__ */ new Map();
+  const changesByObsLocal = /* @__PURE__ */ new Map();
+  const previousByObs = /* @__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 targetMap = inRemoteChange ? outRemote : outLocal;
+    const changesMap = inRemoteChange ? changesByObsRemote : changesByObsLocal;
+    const existing = changesMap.get(obs);
+    const newChanges = existing ? [...existing, ...changes] : changes;
+    const merged = mergeChanges(newChanges);
+    changesMap.set(obs, merged);
+    value.changes = merged;
+    if (!previousByObs.has(obs)) {
+      previousByObs.set(obs, getPrevious());
     }
-    return Array.from(outRemote.values()).concat(Array.from(outLocal.values()));
+    value.valuePrevious = previousByObs.get(obs);
+    targetMap.set(obs, value);
+  }
+  return Array.from(outRemote.values()).concat(Array.from(outLocal.values()));
 }
 async function processQueuedChanges() {
-    var _a;
-    // Get a local copy of the queued changes and clear the global queue
-    const queuedChanges = mergeQueuedChanges(_queuedChanges);
-    _queuedChanges = [];
-    const pendingSyncOptions = new Set();
-    for (let i = 0; i < queuedChanges.length; i++) {
-        const change = queuedChanges[i];
-        if (!change.inRemoteChange) {
-            if (!_queuedRemoteChanges.has(change.syncOptions)) {
-                _queuedRemoteChanges.set(change.syncOptions, []);
-            }
-            pendingSyncOptions.add(change.syncOptions);
-            _queuedRemoteChanges.get(change.syncOptions).push(change);
-        }
+  var _a, _b;
+  const queuedChanges = mergeQueuedChanges(_queuedChanges);
+  _queuedChanges = [];
+  const pendingSyncOptions = /* @__PURE__ */ new Set();
+  for (let i = 0; i < queuedChanges.length; i++) {
+    const change = queuedChanges[i];
+    if (!change.inRemoteChange) {
+      if (!_queuedRemoteChanges.has(change.syncOptions)) {
+        _queuedRemoteChanges.set(change.syncOptions, []);
+      }
+      pendingSyncOptions.add(change.syncOptions);
+      _queuedRemoteChanges.get(change.syncOptions).push(change);
     }
-    // Note: Summary of the order of operations these functions:
-    // 1. Prepare all changes for saving. This may involve waiting for promises if the user has asynchronous transform.
-    // We need to prepare all of the changes in the queue before saving so that the saves happen in the correct order,
-    // since some may take longer to transformSaveData than others.
-    // 2. Save pending to the metadata table first. If this is the only operation that succeeds, it would try to save
-    // the current value again on next load, which isn't too bad.
-    // 3. Save local changes to storage. If they never make it to remote, then on the next load they will be pending
-    // and attempted again.
-    // 4. Wait for remote load or error if allowed
-    // 5. Save to remote
-    // 6. On successful save, merge changes (if any) back into observable
-    // 7. Lastly, update metadata to clear pending and update lastSync. Doing this earlier could potentially cause
-    // sync inconsistences so it's very important that this is last.
-    const preppedChangesLocal = await Promise.all(queuedChanges.map(prepChangeLocal));
-    // TODO Clean this up: We only need to prep this now in order to save pending changes, don't need any of the other stuff. Should split that up?
-    await Promise.all(queuedChanges.map(prepChangeRemote));
-    await Promise.all(preppedChangesLocal.map(doChangeLocal));
-    for (const options of pendingSyncOptions) {
-        const timeout = (_a = options.debounceSet) !== null && _a !== void 0 ? _a : observableSyncConfiguration === null || observableSyncConfiguration === void 0 ? void 0 : observableSyncConfiguration.debounceSet;
-        const timeoutSaveRemote = _queuedRemoteChangesTimeouts.get(options);
-        const run = () => processQueuedRemoteChanges(options);
-        if (timeout) {
-            if (timeoutSaveRemote) {
-                clearTimeout(timeoutSaveRemote);
-            }
-            _queuedRemoteChangesTimeouts.set(options, setTimeout(run, timeout));
-        }
-        else {
-            run();
-        }
+  }
+  const preppedChangesLocal = await Promise.all(queuedChanges.map(prepChangeLocal));
+  await Promise.all(queuedChanges.map(prepChangeRemote));
+  await Promise.all(preppedChangesLocal.map(doChangeLocal));
+  for (const options of pendingSyncOptions) {
+    const timeout = (_b = options.debounceSet) != null ? _b : (_a = observableSyncConfiguration) == null ? void 0 : _a.debounceSet;
+    const timeoutSaveRemote = _queuedRemoteChangesTimeouts.get(options);
+    const run = () => processQueuedRemoteChanges(options);
+    if (timeout) {
+      if (timeoutSaveRemote) {
+        clearTimeout(timeoutSaveRemote);
+      }
+      _queuedRemoteChangesTimeouts.set(options, setTimeout(run, timeout));
+    } else {
+      run();
     }
+  }
 }
 async function processQueuedRemoteChanges(syncOptions) {
-    const arr = _queuedRemoteChanges.get(syncOptions);
-    if (arr === null || arr === void 0 ? void 0 : arr.length) {
-        const queuedRemoteChanges = mergeQueuedChanges(arr);
-        _queuedRemoteChanges.set(syncOptions, []);
-        const preppedChangesRemote = await Promise.all(queuedRemoteChanges.map(prepChangeRemote));
-        preppedChangesRemote.forEach(doChangeRemote);
-    }
+  const arr = _queuedRemoteChanges.get(syncOptions);
+  if (arr == null ? void 0 : arr.length) {
+    const queuedRemoteChanges = mergeQueuedChanges(arr);
+    _queuedRemoteChanges.set(syncOptions, []);
+    const preppedChangesRemote = await Promise.all(queuedRemoteChanges.map(prepChangeRemote));
+    preppedChangesRemote.forEach(doChangeRemote);
+  }
 }
 async function prepChangeLocal(queuedChange) {
-    const { syncState, changes, localState, syncOptions, inRemoteChange, isApplyingPending } = queuedChange;
-    const persist = syncOptions.persist;
-    const { pluginSync } = localState;
-    const { config: configLocal } = parseLocalConfig(persist);
-    const configRemote = syncOptions;
-    const saveLocal = (persist === null || persist === void 0 ? void 0 : persist.name) && !configLocal.readonly && !isApplyingPending && syncState.isPersistEnabled.peek();
-    const saveRemote = !!(!inRemoteChange &&
-        (pluginSync === null || pluginSync === void 0 ? void 0 : pluginSync.set) &&
-        (configRemote === null || configRemote === void 0 ? void 0 : configRemote.enableSync) !== false &&
-        syncState.isSyncEnabled.peek());
-    if (saveLocal || saveRemote) {
-        if (saveLocal && !syncState.isPersistLoaded.peek()) {
-            console.error('[legend-state] WARNING: An observable was changed before being loaded from persist', persist);
-            return undefined;
-        }
-        const changesLocal = [];
-        const changesPaths = new Set();
-        let promisesTransform = [];
-        // Reverse order
-        for (let i = changes.length - 1; i >= 0; i--) {
-            const { path } = changes[i];
-            let found = false;
-            // Optimization to only save the latest update at each path. We might have multiple changes at the same path
-            // and we only need the latest value, so it starts from the end of the array, skipping any earlier changes
-            // already processed. If a later change modifies a parent of an earlier change (which happens on delete()
-            // it should be ignored as it's superseded by the parent modification.
-            if (changesPaths.size > 0) {
-                for (let u = 0; u < path.length; u++) {
-                    if (changesPaths.has((u === path.length - 1 ? path : path.slice(0, u + 1)).join('/'))) {
-                        found = true;
-                        break;
-                    }
-                }
-            }
-            if (!found) {
-                const pathStr = path.join('/');
-                changesPaths.add(pathStr);
-                const { prevAtPath, valueAtPath, pathTypes } = changes[i];
-                if (saveLocal) {
-                    const promiseTransformLocal = transformSaveData(valueAtPath, path, pathTypes, configLocal);
-                    promisesTransform.push(doInOrder(promiseTransformLocal, (valueTransformed) => {
-                        // Prepare the local change with the transformed path/value
-                        changesLocal.push({
-                            path,
-                            pathTypes,
-                            prevAtPath,
-                            valueAtPath: valueTransformed,
-                            pathStr,
-                        });
-                    }));
-                }
-            }
+  const { syncState, changes, localState, 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());
+  if (saveLocal || saveRemote) {
+    if (saveLocal && !syncState.isPersistLoaded.peek()) {
+      console.error(
+        "[legend-state] WARNING: An observable was changed before being loaded from persist",
+        persist
+      );
+      return void 0;
+    }
+    const changesLocal = [];
+    const changesPaths = /* @__PURE__ */ new Set();
+    let promisesTransform = [];
+    for (let i = changes.length - 1; i >= 0; i--) {
+      const { path } = changes[i];
+      let found = false;
+      if (changesPaths.size > 0) {
+        for (let u = 0; u < path.length; u++) {
+          if (changesPaths.has((u === path.length - 1 ? path : path.slice(0, u + 1)).join("/"))) {
+            found = true;
+            break;
+          }
         }
-        // If there's any transform promises, wait for them before saving
-        promisesTransform = promisesTransform.filter(Boolean);
-        if (promisesTransform.length > 0) {
-            await Promise.all(promisesTransform);
+      }
+      if (!found) {
+        const pathStr = path.join("/");
+        changesPaths.add(pathStr);
+        const { prevAtPath, valueAtPath, pathTypes } = changes[i];
+        if (saveLocal) {
+          const promiseTransformLocal = transformSaveData(
+            valueAtPath,
+            path,
+            pathTypes,
+            configLocal
+          );
+          promisesTransform.push(
+            doInOrder(promiseTransformLocal, (valueTransformed) => {
+              changesLocal.push({
+                path,
+                pathTypes,
+                prevAtPath,
+                valueAtPath: valueTransformed,
+                pathStr
+              });
+            })
+          );
         }
-        return { queuedChange, changesLocal, saveRemote };
+      }
+    }
+    promisesTransform = promisesTransform.filter(Boolean);
+    if (promisesTransform.length > 0) {
+      await Promise.all(promisesTransform);
     }
+    return { queuedChange, changesLocal, saveRemote };
+  }
 }
 async function prepChangeRemote(queuedChange) {
-    const { syncState, changes, localState, syncOptions: syncOptions, inRemoteChange, isApplyingPending, valuePrevious, } = 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 || pluginSync === void 0 ? void 0 : pluginSync.set) && (configRemote === null || configRemote === void 0 ? void 0 : configRemote.enableSync) !== false && syncState.isSyncEnabled.peek();
-    if (saveLocal || saveRemote) {
-        if (saveLocal && !syncState.isPersistLoaded.peek()) {
-            console.error('[legend-state] WARNING: An observable was changed before being loaded from persist', persist);
-            return undefined;
+  const {
+    syncState,
+    changes,
+    localState,
+    syncOptions,
+    inRemoteChange,
+    isApplyingPending,
+    valuePrevious
+  } = 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();
+  if (saveLocal || saveRemote) {
+    if (saveLocal && !syncState.isPersistLoaded.peek()) {
+      console.error(
+        "[legend-state] WARNING: An observable was changed before being loaded from persist",
+        persist
+      );
+      return void 0;
+    }
+    const changesRemote = [];
+    const changesPaths = /* @__PURE__ */ new Set();
+    let promisesTransform = [];
+    for (let i = changes.length - 1; i >= 0; i--) {
+      const { path } = changes[i];
+      let found = false;
+      if (changesPaths.size > 0) {
+        for (let u = 0; u < path.length; u++) {
+          if (changesPaths.has((u === path.length - 1 ? path : path.slice(0, u + 1)).join("/"))) {
+            found = true;
+            break;
+          }
         }
-        const changesRemote = [];
-        const changesPaths = new Set();
-        let promisesTransform = [];
-        // Reverse order
-        for (let i = changes.length - 1; i >= 0; i--) {
-            const { path } = changes[i];
-            let found = false;
-            // Optimization to only save the latest update at each path. We might have multiple changes at the same path
-            // and we only need the latest value, so it starts from the end of the array, skipping any earlier changes
-            // already processed. If a later change modifies a parent of an earlier change (which happens on delete()
-            // it should be ignored as it's superseded by the parent modification.
-            if (changesPaths.size > 0) {
-                for (let u = 0; u < path.length; u++) {
-                    if (changesPaths.has((u === path.length - 1 ? path : path.slice(0, u + 1)).join('/'))) {
-                        found = true;
-                        break;
-                    }
+      }
+      if (!found) {
+        const pathStr = path.join("/");
+        changesPaths.add(pathStr);
+        const { prevAtPath, valueAtPath, pathTypes } = changes[i];
+        if (saveRemote) {
+          const promiseTransformRemote = transformSaveData(
+            valueAtPath,
+            path,
+            pathTypes,
+            configRemote || {}
+          );
+          promisesTransform.push(
+            doInOrder(promiseTransformRemote, (valueTransformed) => {
+              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("/");
+                if ((_a = localState.pendingChanges[pathParent]) == null ? void 0 : _a.v) {
+                  found2 = true;
+                  const pathChild = path.slice(i2 + 1);
+                  const pathTypesChild = pathTypes.slice(i2 + 1);
+                  state.setAtPath(
+                    localState.pendingChanges[pathParent].v,
+                    pathChild,
+                    pathTypesChild,
+                    valueAtPath
+                  );
                 }
-            }
-            if (!found) {
-                const pathStr = path.join('/');
-                changesPaths.add(pathStr);
-                const { prevAtPath, valueAtPath, pathTypes } = changes[i];
-                if (saveRemote) {
-                    const promiseTransformRemote = transformSaveData(valueAtPath, path, pathTypes, configRemote || {});
-                    promisesTransform.push(doInOrder(promiseTransformRemote, (valueTransformed) => {
-                        var _a;
-                        // Prepare pending changes
-                        if (!localState.pendingChanges) {
-                            localState.pendingChanges = {};
-                        }
-                        // First look for existing pending changes at a higher level than this change
-                        // If they exist then merge this change into it
-                        let found = false;
-                        for (let i = 0; !found && i < path.length - 1; i++) {
-                            const pathParent = path.slice(0, i + 1).join('/');
-                            if ((_a = localState.pendingChanges[pathParent]) === null || _a === void 0 ? void 0 : _a.v) {
-                                found = true;
-                                const pathChild = path.slice(i + 1);
-                                const pathTypesChild = pathTypes.slice(i + 1);
-                                state.setAtPath(localState.pendingChanges[pathParent].v, pathChild, pathTypesChild, valueAtPath);
-                            }
-                        }
-                        if (!found) {
-                            // If an existing pending change is deeper than this change, just delete it
-                            // in favor of this wider change
-                            for (const key in localState.pendingChanges) {
-                                if (key !== pathStr && key.startsWith(pathStr)) {
-                                    delete localState.pendingChanges[key];
-                                }
-                            }
-                            // The "p" saved in pending should be the previous state before changes,
-                            // so don't overwrite it if it already exists
-                            if (!localState.pendingChanges[pathStr]) {
-                                localState.pendingChanges[pathStr] = { p: prevAtPath !== null && prevAtPath !== void 0 ? prevAtPath : null, t: pathTypes };
-                            }
-                            // Pending value is the untransformed value because it gets loaded without transformment
-                            // and forwarded through to onObsChange where it gets transformed before save
-                            localState.pendingChanges[pathStr].v = valueAtPath;
-                        }
-                        // Prepare the remote change with the transformed path/value
-                        changesRemote.push({
-                            path,
-                            pathTypes,
-                            prevAtPath,
-                            valueAtPath: valueTransformed,
-                            pathStr,
-                            valuePrevious,
-                        });
-                    }));
+              }
+              if (!found2) {
+                for (const key in localState.pendingChanges) {
+                  if (key !== pathStr && key.startsWith(pathStr)) {
+                    delete localState.pendingChanges[key];
+                  }
                 }
-            }
-        }
-        // If there's any transform promises, wait for them before saving
-        promisesTransform = promisesTransform.filter(Boolean);
-        if (promisesTransform.length > 0) {
-            await Promise.all(promisesTransform);
+                if (!localState.pendingChanges[pathStr]) {
+                  localState.pendingChanges[pathStr] = { p: prevAtPath != null ? prevAtPath : null, t: pathTypes };
+                }
+                localState.pendingChanges[pathStr].v = valueAtPath;
+              }
+              changesRemote.push({
+                path,
+                pathTypes,
+                prevAtPath,
+                valueAtPath: valueTransformed,
+                pathStr,
+                valuePrevious
+              });
+            })
+          );
         }
-        return { queuedChange, changesRemote };
+      }
     }
+    promisesTransform = promisesTransform.filter(Boolean);
+    if (promisesTransform.length > 0) {
+      await Promise.all(promisesTransform);
+    }
+    return { queuedChange, changesRemote };
+  }
 }
 async function doChangeLocal(changeInfo) {
-    if (!changeInfo)
-        return;
-    const { queuedChange, changesLocal, saveRemote } = changeInfo;
-    const { value$: obs, syncState, localState, syncOptions: syncOptions } = queuedChange;
-    const { pluginPersist } = localState;
-    const persist = syncOptions.persist;
-    const { table, config: configLocal } = parseLocalConfig(persist);
-    const shouldSaveMetadata = persist === null || persist === void 0 ? void 0 : persist.retrySync;
-    if (saveRemote && shouldSaveMetadata) {
-        // First save pending changes before saving local or remote
-        await updateMetadataImmediate(obs, localState, syncState, syncOptions, {
-            pending: localState.pendingChanges,
-        });
-    }
-    if (changesLocal.length > 0) {
-        // Save the changes to local cache before saving to remote. They are already marked as pending so
-        // if remote sync fails or the app is closed before remote sync, it will attempt to sync them on the next load.
-        let promiseSet = pluginPersist.set(table, changesLocal, configLocal);
-        if (promiseSet) {
-            promiseSet = promiseSet.then(() => {
-                promisesLocalSaves.delete(promiseSet);
-            });
-            // Keep track of local save promises so that updateMetadata runs only after everything is saved
-            promisesLocalSaves.add(promiseSet);
-            // await the local save before proceeding to save remotely
-            await promiseSet;
-        }
+  if (!changeInfo)
+    return;
+  const { queuedChange, changesLocal, saveRemote } = changeInfo;
+  const { value$: obs, syncState, 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);
+      });
+      promisesLocalSaves.add(promiseSet);
+      await promiseSet;
     }
+  }
 }
 async function doChangeRemote(changeInfo) {
-    var _a, _b;
-    if (!changeInfo)
-        return;
-    const { queuedChange, changesRemote } = changeInfo;
-    const { value$: obs, syncState, localState, syncOptions, valuePrevious: previous } = queuedChange;
-    const { pluginPersist, pluginSync } = localState;
-    const persist = syncOptions.persist;
-    const { table, config: configLocal } = parseLocalConfig(persist);
-    const { allowSetIfGetError, onBeforeSet, onSetError, waitForSet, onAfterSet } = syncOptions || {};
-    const shouldSaveMetadata = persist === null || persist === void 0 ? void 0 : persist.retrySync;
-    if (changesRemote.length > 0) {
-        // Wait for remote to be ready before saving
-        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);
+  var _a, _b;
+  if (!changeInfo)
+    return;
+  const { queuedChange, changesRemote } = changeInfo;
+  const { value$: obs, syncState, localState, syncOptions, valuePrevious: previous } = queuedChange;
+  const { pluginPersist, pluginSync } = localState;
+  const persist = syncOptions.persist;
+  const { table, config: configLocal } = parseLocalConfig(persist);
+  const { allowSetIfGetError, onBeforeSet, onSetError, waitForSet, onAfterSet } = syncOptions || {};
+  const shouldSaveMetadata = persist == null ? void 0 : persist.retrySync;
+  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);
+      }
+    }
+    let value = obs.peek();
+    const transformSave = (_a = syncOptions == null ? void 0 : syncOptions.transform) == null ? void 0 : _a.save;
+    if (transformSave) {
+      value = transformSave(clone(value));
+    }
+    onBeforeSet == null ? void 0 : onBeforeSet();
+    localState.numSavesOutstanding = (localState.numSavesOutstanding || 0) + 1;
+    let savedPromise = pluginSync.set({
+      value$: obs,
+      syncState,
+      options: syncOptions,
+      changes: changesRemote,
+      value,
+      valuePrevious: previous
+    });
+    if (state.isPromise(savedPromise)) {
+      savedPromise = savedPromise.catch((err) => onSetError == null ? void 0 : onSetError(err));
+    }
+    const saved = await savedPromise;
+    localState.numSavesOutstanding--;
+    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 (persist) {
+          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 (lastSync) {
+            metadata.lastSync = lastSync;
+          }
         }
-        let value = obs.peek();
-        const transformSave = (_a = syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.transform) === null || _a === void 0 ? void 0 : _a.save;
-        if (transformSave) {
-            // Clone value before transforming to ensure it doesn't change observable value
-            value = transformSave(clone(value));
-        }
-        onBeforeSet === null || onBeforeSet === void 0 ? void 0 : onBeforeSet();
-        localState.numSavesOutstanding = (localState.numSavesOutstanding || 0) + 1;
-        let savedPromise = pluginSync.set({
-            value$: obs,
-            syncState: syncState,
-            options: syncOptions,
-            changes: changesRemote,
-            value,
-            valuePrevious: previous,
-        });
-        if (state.isPromise(savedPromise)) {
-            savedPromise = savedPromise.catch((err) => onSetError === null || onSetError === void 0 ? void 0 : onSetError(err));
+        if (changes && !state.isEmpty(changes)) {
+          transformedChanges = transformLoadData(changes, syncOptions, false, "set");
         }
-        const saved = await savedPromise;
-        localState.numSavesOutstanding--;
-        // If this remote save changed anything then update cache and metadata
-        // Because save happens after a timeout and they're batched together, some calls to save will
-        // return saved data and others won't, so those can be ignored.
-        if (saved !== undefined) {
-            const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
-            const { changes, lastSync } = saved;
-            if (pathStrs.length > 0) {
-                let transformedChanges = undefined;
-                const metadata = {};
-                if (persist) {
-                    const pendingMetadata = (_b = pluginPersist.getMetadata(table, configLocal)) === null || _b === void 0 ? void 0 : _b.pending;
-                    const pending = localState.pendingChanges;
-                    for (let i = 0; i < pathStrs.length; i++) {
-                        const pathStr = pathStrs[i];
-                        // Clear pending for this path
-                        if (pendingMetadata === null || pendingMetadata === void 0 ? void 0 : pendingMetadata[pathStr]) {
-                            // Remove pending from persisted medata state
-                            delete pendingMetadata[pathStr];
-                            metadata.pending = pendingMetadata;
-                        }
-                        // Clear pending for this path if not already removed by above
-                        // pendingMetadata === pending sometimes
-                        if (pending === null || pending === void 0 ? void 0 : pending[pathStr]) {
-                            // Remove pending from local state
-                            delete pending[pathStr];
-                        }
-                    }
-                    if (lastSync) {
-                        metadata.lastSync = lastSync;
-                    }
-                }
-                // Remote can optionally have data that needs to be merged back into the observable,
-                // for example Firebase may update dateModified with the server timestamp
-                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);
-                    }
-                }
-                else {
-                    let allChanges = [...(localState.pendingSaveResults || []), transformedChanges].filter((v) => v !== undefined);
-                    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);
-                        }
-                    }
-                    localState.pendingSaveResults = [];
-                }
-                onAfterSet === null || onAfterSet === void 0 ? void 0 : onAfterSet();
+        if (localState.numSavesOutstanding > 0) {
+          if (transformedChanges) {
+            if (!localState.pendingSaveResults) {
+              localState.pendingSaveResults = [];
             }
+            localState.pendingSaveResults.push(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);
+            }
+          }
+          localState.pendingSaveResults = [];
         }
+        onAfterSet == null ? void 0 : onAfterSet();
+      }
     }
+  }
 }
 function onObsChange(value$, syncState, localState, syncOptions, { changes, loading, remote, getPrevious }) {
-    if (!loading) {
-        const inRemoteChange = remote;
-        const isApplyingPending = localState.isApplyingPending;
-        // Queue changes in a microtask so that multiple changes within a frame get run together
-        _queuedChanges.push({
-            value$: value$,
-            syncState,
-            localState,
-            syncOptions,
-            changes,
-            inRemoteChange,
-            isApplyingPending: isApplyingPending,
-            getPrevious,
-        });
-        if (_queuedChanges.length === 1) {
-            queueMicrotask(processQueuedChanges);
-        }
+  if (!loading) {
+    const inRemoteChange = remote;
+    const isApplyingPending = localState.isApplyingPending;
+    _queuedChanges.push({
+      value$,
+      syncState,
+      localState,
+      syncOptions,
+      changes,
+      inRemoteChange,
+      isApplyingPending,
+      getPrevious
+    });
+    if (_queuedChanges.length === 1) {
+      queueMicrotask(processQueuedChanges);
     }
+  }
 }
 async function loadLocal(value$, syncOptions, syncState, localState) {
-    var _a, _b;
-    const { persist } = syncOptions;
-    if (persist) {
-        const PersistPlugin = persist.plugin || ((_a = observableSyncConfiguration.persist) === null || _a === void 0 ? void 0 : _a.plugin);
-        const { table, config } = parseLocalConfig(persist);
-        const node = getNode(value$);
-        if (!PersistPlugin) {
-            throw new Error('Local persist is not configured');
-        }
-        // Ensure there's only one instance of the cache plugin
-        if (!mapSyncPlugins.has(PersistPlugin)) {
-            const persistPlugin = new PersistPlugin();
-            const mapValue = { plugin: persistPlugin, initialized: state.observable(false) };
-            mapSyncPlugins.set(PersistPlugin, mapValue);
-            if (persistPlugin.initialize) {
-                const initializePromise = (_b = persistPlugin.initialize) === null || _b === void 0 ? void 0 : _b.call(persistPlugin, (observableSyncConfiguration === null || observableSyncConfiguration === void 0 ? void 0 : observableSyncConfiguration.persist) || {});
-                if (state.isPromise(initializePromise)) {
-                    await initializePromise;
-                }
-            }
-            mapValue.initialized.set(true);
-        }
-        const { plugin, initialized: initialized$ } = mapSyncPlugins.get(PersistPlugin);
-        const persistPlugin = plugin;
-        localState.pluginPersist = persistPlugin;
-        if (!initialized$.peek()) {
-            await state.when(initialized$);
-        }
-        // If cache has an asynchronous load, wait for it
-        if (persistPlugin.loadTable) {
-            const promise = persistPlugin.loadTable(table, config);
-            if (promise) {
-                await promise;
-            }
-        }
-        // Get current value for init
-        const prevValue = getNodeValue$1(node);
-        // Get the value from state
-        let value = persistPlugin.getTable(table, prevValue, config);
-        const metadata = persistPlugin.getMetadata(table, config);
-        if (metadata) {
-            metadatas.set(value$, metadata);
-            localState.pendingChanges = metadata.pending;
-            syncState.assign({
-                lastSync: metadata.lastSync,
-            });
-        }
-        // Merge the data from local cache into the default state
-        if (value !== undefined) {
-            const { transform } = config;
-            value = transformLoadData(value, { transform }, true, 'get');
-            if (state.isPromise(value)) {
-                value = await value;
-            }
-            // isLoadingLocal prevents saving remotely when two different caches
-            // are set on the same observable
-            state.internal.globalState.isLoadingLocal = true;
-            // We want to merge the local data on top of any initial state the object is created with
-            if (value === null && (!prevValue || prevValue[symbolLinked$1])) {
-                value$.set(value);
-            }
-            else {
-                state.mergeIntoObservable(value$, value);
-            }
-            state.internal.globalState.isLoadingLocal = false;
+  var _a, _b, _c;
+  const { persist } = syncOptions;
+  if (persist) {
+    const PersistPlugin = persist.plugin || ((_a = observableSyncConfiguration.persist) == null ? void 0 : _a.plugin);
+    const { table, config } = parseLocalConfig(persist);
+    const node = getNode(value$);
+    if (!PersistPlugin) {
+      throw new Error("Local persist is not configured");
+    }
+    if (!mapSyncPlugins.has(PersistPlugin)) {
+      const persistPlugin2 = new PersistPlugin();
+      const mapValue = { plugin: persistPlugin2, initialized: state.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 (state.isPromise(initializePromise)) {
+          await initializePromise;
         }
-        getNodeValue$1(getNode(node.state)).clearPersist = () => Promise.all([
-            persistPlugin.deleteTable(table, config),
-            persistPlugin.deleteMetadata(table, config),
-        ]);
+      }
+      mapValue.initialized.set(true);
+    }
+    const { plugin, initialized: initialized$ } = mapSyncPlugins.get(PersistPlugin);
+    const persistPlugin = plugin;
+    localState.pluginPersist = persistPlugin;
+    if (!initialized$.peek()) {
+      await state.when(initialized$);
     }
-    syncState.isPersistLoaded.set(true);
+    if (persistPlugin.loadTable) {
+      const promise = persistPlugin.loadTable(table, config);
+      if (promise) {
+        await promise;
+      }
+    }
+    const prevValue = getNodeValue(node);
+    let value = persistPlugin.getTable(table, prevValue, config);
+    const metadata = persistPlugin.getMetadata(table, config);
+    if (metadata) {
+      metadatas.set(value$, metadata);
+      localState.pendingChanges = metadata.pending;
+      syncState.assign({
+        lastSync: metadata.lastSync
+      });
+    }
+    if (value !== void 0) {
+      const { transform } = config;
+      value = transformLoadData(value, { transform }, true, "get");
+      if (state.isPromise(value)) {
+        value = await value;
+      }
+      state.internal.globalState.isLoadingLocal = true;
+      if (value === null && (!prevValue || prevValue[symbolLinked])) {
+        value$.set(value);
+      } else {
+        state.mergeIntoObservable(value$, value);
+      }
+      state.internal.globalState.isLoadingLocal = false;
+    }
+    getNodeValue(getNode(node.state)).clearPersist = () => Promise.all([
+      persistPlugin.deleteTable(table, config),
+      persistPlugin.deleteMetadata(table, config)
+    ]);
+  }
+  syncState.isPersistLoaded.set(true);
 }
 function syncObservable(obs$, syncOptionsOrSynced) {
-    let syncOptions = syncOptionsOrSynced;
-    // If it's a synced then get the SyncOptions from it
-    if (state.isFunction(syncOptions)) {
-        syncOptions = syncOptions()[symbolLinked$1];
-    }
-    const node = getNode(obs$);
-    // Merge remote sync options with global options
-    syncOptions = {
-        syncMode: 'auto',
-        ...observableSyncConfiguration,
-        ...removeNullUndefined(syncOptions || {}),
-    };
-    const localState = {};
-    let sync;
-    const syncState = (node.state = state.observable({
-        isPersistLoaded: false,
-        isLoaded: !syncOptions.get,
-        isPersistEnabled: true,
-        isSyncEnabled: true,
-        clearPersist: undefined,
-        sync: () => Promise.resolve(),
-        getPendingChanges: () => localState.pendingChanges,
-    }));
-    loadLocal(obs$, syncOptions, syncState, localState);
-    localState.pluginSync = syncObservableAdapter(syncOptions);
-    if (syncOptions.get) {
-        let isSynced = false;
-        let isSubscribed = false;
-        let unsubscribe = undefined;
-        sync = async () => {
-            var _a, _b;
-            if (isSynced && state.shouldIgnoreUnobserved(node, sync)) {
-                if (unsubscribe) {
-                    isSubscribed = false;
-                    unsubscribe();
-                    unsubscribe = undefined;
-                }
-                return;
-            }
-            const lastSync = (_a = metadatas.get(obs$)) === null || _a === void 0 ? void 0 : _a.lastSync;
-            const pending = localState.pendingChanges;
-            const get = (_b = localState.pluginSync.get) === null || _b === void 0 ? void 0 : _b.bind(localState.pluginSync);
-            if (get) {
-                const runGet = () => {
-                    const onChange = async ({ value, mode, lastSync }) => {
-                        mode = mode || syncOptions.mode || 'set';
-                        if (value !== undefined) {
-                            value = transformLoadData(value, syncOptions, true, 'get');
-                            if (state.isPromise(value)) {
-                                value = await value;
-                            }
-                            const pending = localState.pendingChanges;
-                            const currentValue = obs$.peek();
-                            if (pending) {
-                                let didChangeMetadata = false;
-                                Object.keys(pending).forEach((key) => {
-                                    const p = key.split('/').filter((p) => p !== '');
-                                    const { v, t } = pending[key];
-                                    if (t.length === 0 || !value) {
-                                        if (state.isObject(value) && state.isObject(v)) {
-                                            Object.assign(value, v);
-                                        }
-                                        else {
-                                            value = v;
-                                        }
-                                    }
-                                    else if (value[p[0]] !== undefined) {
-                                        const curValue = getValueAtPath(currentValue, p);
-                                        const newValue = getValueAtPath(value, p);
-                                        if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
-                                            delete pending[key];
-                                            didChangeMetadata = true;
-                                        }
-                                        else {
-                                            value = state.setAtPath(value, p, t, v, 'merge', obs$.peek(), (path, value) => {
-                                                delete pending[key];
-                                                pending[path.join('/')] = {
-                                                    p: null,
-                                                    v: value,
-                                                    t: t.slice(0, path.length),
-                                                };
-                                            });
-                                        }
-                                    }
-                                });
-                                if (didChangeMetadata) {
-                                    updateMetadata(obs$, localState, syncState, syncOptions, {
-                                        pending,
-                                    });
-                                }
-                            }
-                            onChangeRemote(() => {
-                                if (mode === 'assign' && state.isObject(value)) {
-                                    obs$.assign(value);
-                                }
-                                else if (mode === 'append' && state.isArray(value)) {
-                                    obs$.push(...value);
-                                }
-                                else if (mode === 'prepend' && state.isArray(value)) {
-                                    obs$.splice(0, 0, ...value);
-                                }
-                                else if (mode === 'merge') {
-                                    state.mergeIntoObservable(obs$, value);
-                                }
-                                else {
-                                    obs$.set(value);
-                                }
-                            });
-                        }
-                        if (lastSync && syncOptions.persist) {
-                            updateMetadata(obs$, localState, syncState, syncOptions, {
-                                lastSync,
-                            });
+  let syncOptions = syncOptionsOrSynced;
+  if (state.isFunction(syncOptions)) {
+    syncOptions = syncOptions()[symbolLinked];
+  }
+  const node = getNode(obs$);
+  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && (!obs$ || !node)) {
+    throw new Error("[legend-state] syncObservable called with undefined observable");
+  }
+  syncOptions = {
+    syncMode: "auto",
+    ...observableSyncConfiguration,
+    ...removeNullUndefined(syncOptions || {})
+  };
+  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);
+  if (syncOptions.get) {
+    let isSynced = false;
+    let isSubscribed = false;
+    let unsubscribe = void 0;
+    sync = async () => {
+      var _a, _b;
+      if (isSynced && state.shouldIgnoreUnobserved(node, sync)) {
+        if (unsubscribe) {
+          isSubscribed = false;
+          unsubscribe();
+          unsubscribe = void 0;
+        }
+        return;
+      }
+      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);
+      if (get) {
+        const runGet = () => {
+          const onChange = async ({ value, mode, lastSync: lastSync2 }) => {
+            mode = mode || syncOptions.mode || "set";
+            if (value !== void 0) {
+              value = transformLoadData(value, syncOptions, true, "get");
+              if (state.isPromise(value)) {
+                value = await value;
+              }
+              const pending2 = localState.pendingChanges;
+              const currentValue = obs$.peek();
+              if (pending2) {
+                let didChangeMetadata = false;
+                Object.keys(pending2).forEach((key) => {
+                  const p = key.split("/").filter((p2) => p2 !== "");
+                  const { v, t } = pending2[key];
+                  if (t.length === 0 || !value) {
+                    if (state.isObject(value) && state.isObject(v)) {
+                      Object.assign(value, v);
+                    } else {
+                      value = v;
+                    }
+                  } else if (value[p[0]] !== void 0) {
+                    const curValue = getValueAtPath(currentValue, p);
+                    const newValue = getValueAtPath(value, p);
+                    if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
+                      delete pending2[key];
+                      didChangeMetadata = true;
+                    } else {
+                      value = state.setAtPath(
+                        value,
+                        p,
+                        t,
+                        v,
+                        "merge",
+                        obs$.peek(),
+                        (path, value2) => {
+                          delete pending2[key];
+                          pending2[path.join("/")] = {
+                            p: null,
+                            v: value2,
+                            t: t.slice(0, path.length)
+                          };
                         }
-                    };
-                    get({
-                        state: syncState,
-                        value$: obs$,
-                        options: syncOptions,
-                        lastSync,
-                        dateModified: lastSync,
-                        onError: (error) => {
-                            var _a;
-                            (_a = syncOptions.onGetError) === null || _a === void 0 ? void 0 : _a.call(syncOptions, error);
-                        },
-                        onGet: () => {
-                            node.state.assign({
-                                isLoaded: true,
-                                error: undefined,
-                            });
-                        },
-                        onChange,
-                    });
-                    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),
-                        });
+                      );
                     }
-                };
-                runGet();
-            }
-            else {
-                node.state.assign({
-                    isLoaded: true,
-                    error: undefined,
+                  }
                 });
-            }
-            if (!isSynced) {
-                isSynced = true;
-                // Wait for remote to be ready before saving pending
-                await state.when(() => syncState.isLoaded.get() || (syncOptions.allowSetIfGetError && syncState.error.get()));
-                if (pending && !state.isEmpty(pending)) {
-                    localState.isApplyingPending = true;
-                    const keys = Object.keys(pending);
-                    // Bundle up all the changes from pending
-                    const changes = [];
-                    for (let i = 0; i < keys.length; i++) {
-                        const key = keys[i];
-                        const path = key.split('/').filter((p) => p !== '');
-                        const { p, v, t } = pending[key];
-                        changes.push({ path, valueAtPath: v, prevAtPath: p, pathTypes: t });
-                    }
-                    // Send the changes into onObsChange so that they get synced remotely
-                    const value = getNodeValue$1(node);
-                    onObsChange(obs$, syncState, localState, syncOptions, {
-                        value,
-                        loading: false,
-                        remote: false,
-                        getPrevious: createPreviousHandler(value, changes),
-                        changes,
-                    });
-                    localState.isApplyingPending = false;
+                if (didChangeMetadata) {
+                  updateMetadata(obs$, localState, syncState, syncOptions, {
+                    pending: pending2
+                  });
                 }
+              }
+              onChangeRemote(() => {
+                if (mode === "assign" && state.isObject(value)) {
+                  obs$.assign(value);
+                } else if (mode === "append" && state.isArray(value)) {
+                  obs$.push(...value);
+                } else if (mode === "prepend" && state.isArray(value)) {
+                  obs$.splice(0, 0, ...value);
+                } else if (mode === "merge") {
+                  state.mergeIntoObservable(obs$, value);
+                } else {
+                  obs$.set(value);
+                }
+              });
             }
-        };
-        syncState.assign({ sync });
-    }
-    // Wait for this node and all parent nodes up the hierarchy to be loaded
-    const onAllPersistLoaded = () => {
-        var _a, _b;
-        let parentNode = node;
-        while (parentNode) {
-            if (((_b = (_a = parentNode.state) === null || _a === void 0 ? void 0 : _a.isPersistLoaded) === null || _b === void 0 ? void 0 : _b.get()) === false) {
-                return false;
+            if (lastSync2 && syncOptions.persist) {
+              updateMetadata(obs$, localState, syncState, syncOptions, {
+                lastSync: lastSync2
+              });
             }
-            parentNode = parentNode.parent;
+          };
+          get({
+            state: syncState,
+            value$: obs$,
+            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
+              });
+            },
+            onChange
+          });
+          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)
+            });
+          }
+        };
+        runGet();
+      } else {
+        node.state.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;
         }
-        return true;
+      }
     };
-    // When all is loaded locally we can start syncing and listening for changes
-    state.when(onAllPersistLoaded, function () {
-        // If remote is not manual, then sync() is called automatically
-        if (syncOptions.get && syncOptions.syncMode === 'auto') {
-            sync();
-        }
-        if ((syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.set) || (syncOptions === null || syncOptions === void 0 ? void 0 : syncOptions.persist)) {
-            obs$.onChange(onObsChange.bind(this, obs$, syncState, localState, syncOptions));
-        }
-    });
-    return syncState;
+    syncState.assign({ sync });
+  }
+  const onAllPersistLoaded = () => {
+    var _a, _b;
+    let parentNode = node;
+    while (parentNode) {
+      if (((_b = (_a = parentNode.state) == null ? void 0 : _a.isPersistLoaded) == null ? void 0 : _b.get()) === false) {
+        return false;
+      }
+      parentNode = parentNode.parent;
+    }
+    return true;
+  };
+  state.when(onAllPersistLoaded, function() {
+    if (syncOptions.get && syncOptions.syncMode === "auto") {
+      sync();
+    }
+    if ((syncOptions == null ? void 0 : syncOptions.set) || (syncOptions == null ? void 0 : syncOptions.persist)) {
+      obs$.onChange(
+        onObsChange.bind(this, obs$, syncState, localState, syncOptions)
+      );
+    }
+  });
+  return syncState;
 }
-
-const { getProxy, globalState, runWithRetry, symbolLinked, setNodeValue, getNodeValue } = state.internal;
+var { getProxy, globalState: globalState2, runWithRetry, symbolLinked: symbolLinked2, setNodeValue, getNodeValue: getNodeValue2 } = state.internal;
 function enableActivateSyncedNode() {
-    globalState.activateSyncedNode = function activateSyncedNode(node, newValue) {
-        const obs$ = getProxy(node);
-        if (node.activationState) {
-            // If it is a Synced
-            const { get, initial, set, retry } = node.activationState;
-            let onChange = undefined;
-            const pluginRemote = {};
-            let promiseReturn = undefined;
-            // Not sure why this disable is needed, but it's needed to make the linter happy
-            // eslint-disable-next-line prefer-const
-            let syncState;
-            const refresh = () => syncState === null || syncState === void 0 ? void 0 : syncState.sync();
-            if (get) {
-                pluginRemote.get = (params) => {
-                    var _a;
-                    onChange = params.onChange;
-                    const updateLastSync = (lastSync) => (params.lastSync = lastSync);
-                    const existingValue = getNodeValue(node);
-                    const value = runWithRetry(node, { attemptNum: 0, retry: retry || ((_a = params.options) === null || _a === void 0 ? void 0 : _a.retry) }, () => {
-                        const paramsToGet = {
-                            value: state.isFunction(existingValue) || (existingValue === null || existingValue === void 0 ? void 0 : existingValue[symbolLinked]) ? undefined : 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) {
-                // TODO: Work out these types better
-                pluginRemote.set = async (params) => {
-                    var _a, _b;
-                    if ((_a = node.state) === null || _a === void 0 ? void 0 : _a.isLoaded.get()) {
-                        const retryAttempts = { attemptNum: 0, retry: retry || ((_b = params.options) === null || _b === void 0 ? 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: (params) => {
-                                    const { value, lastSync } = params;
-                                    maxModified = Math.max(lastSync || 0, maxModified);
-                                    changes = state.mergeIntoObservable(changes, value);
-                                },
-                                retryNum: retryAttempts.attemptNum,
-                                cancelRetry,
-                                refresh,
-                                fromSubscribe: false,
-                            });
-                            return { changes, lastSync: maxModified || undefined };
-                        });
-                    }
-                };
-            }
-            const nodeVal = getNodeValue(node);
-            if (promiseReturn !== undefined) {
-                newValue = promiseReturn;
-            }
-            else if (nodeVal !== undefined && !state.isFunction(nodeVal)) {
-                newValue = nodeVal;
-            }
-            else {
-                newValue = initial;
-            }
-            setNodeValue(node, promiseReturn ? undefined : newValue);
-            // @ts-expect-error TODO fix these types
-            syncState = syncObservable(obs$, { ...node.activationState, ...pluginRemote });
-            return { update: onChange, value: newValue };
-        }
-        else {
-            // If it is not a Synced
-            let update = undefined;
-            const get = async (params) => {
-                update = params.refresh;
-                if (state.isPromise(newValue)) {
-                    try {
-                        newValue = await newValue;
-                    }
-                    catch (_a) {
-                        // TODO Once we have global retry settings this should retry
-                    }
-                }
-                return newValue;
+  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 = {};
+      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
             };
-            syncObservable(obs$, {
-                get,
+            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 };
             });
-            return { update: update, value: newValue };
+          }
+        };
+      }
+      const nodeVal = getNodeValue2(node);
+      if (promiseReturn !== void 0) {
+        newValue = promiseReturn;
+      } else if (nodeVal !== void 0 && !state.isFunction(nodeVal)) {
+        newValue = nodeVal;
+      } else {
+        newValue = initial;
+      }
+      setNodeValue(node, promiseReturn ? void 0 : newValue);
+      syncState = syncObservable(obs$, { ...node.activationState, ...pluginRemote });
+      return { update: onChange, value: newValue };
+    } else {
+      let update = void 0;
+      const get = async (params) => {
+        update = params.refresh;
+        if (state.isPromise(newValue)) {
+          try {
+            newValue = await newValue;
+          } catch (e) {
+          }
         }
-    };
+        return newValue;
+      };
+      syncObservable(obs$, {
+        get
+      });
+      return { update, value: newValue };
+    }
+  };
 }
 
+// src/sync/synced.ts
 function synced(params) {
-    installPersistActivateNode();
-    if (state.isFunction(params)) {
-        params = { get: params };
-    }
-    return state.linked({ ...params, synced: true });
+  installPersistActivateNode();
+  if (state.isFunction(params)) {
+    params = { get: params };
+  }
+  return state.linked({ ...params, synced: true });
 }
-let didInstall = false;
+var didInstall = false;
 function installPersistActivateNode() {
-    if (!didInstall) {
-        enableActivateSyncedNode();
-        didInstall = true;
-    }
+  if (!didInstall) {
+    enableActivateSyncedNode();
+    didInstall = true;
+  }
 }
 
+// sync.ts
 function isInRemoteChange() {
-    return state.internal.globalState.isLoadingRemote;
+  return state.internal.globalState.isLoadingRemote;
 }
-const internal = {
-    observableSyncConfiguration,
+var internal3 = {
+  observableSyncConfiguration
 };
 
 exports.combineTransforms = combineTransforms;
 exports.configureObservableSync = configureObservableSync;
 exports.deepEqual = deepEqual;
 exports.diffObjects = diffObjects;
-exports.internal = internal;
+exports.internal = internal3;
 exports.isInRemoteChange = isInRemoteChange;
 exports.mapSyncPlugins = mapSyncPlugins;
 exports.onChangeRemote = onChangeRemote;
@@ -1076,4 +1024,3 @@ exports.syncObservable = syncObservable;
 exports.synced = synced;
 exports.transformStringifyDates = transformStringifyDates;
 exports.transformStringifyKeys = transformStringifyKeys;
-//# sourceMappingURL=sync.js.map