@legendapp/state 1.11.1 → 2.0.0-beta.0

package/persist.js

@@ -135,19 +135,37 @@ if (process.env.NODE_ENV === 'development') {
     };
 }
 
+function observablePersistRemoteFunctionsAdapter({ get, set, }) {
+    const ret = {
+        async get(params) {
+            const value = (await get(params));
+            params.onChange({ value, dateModified: Date.now() });
+            params.onGet();
+        },
+    };
+    if (set) {
+        ret.set = set;
+    }
+    return ret;
+}
+
 const mapPersistences = new WeakMap();
 const persistState = state.observable({ inRemoteSync: false });
 const metadatas = new WeakMap();
 const promisesLocalSaves = new Set();
 function parseLocalConfig(config) {
-    return 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);
 }
-function adjustSaveData(value, path, pathTypes, { adjustData, fieldTransforms, }) {
-    if (fieldTransforms || (adjustData === null || adjustData === void 0 ? void 0 : adjustData.save)) {
-        const transform = () => {
+function transformOutData(value, path, pathTypes, { transform, fieldTransforms }) {
+    if (fieldTransforms || (transform === null || transform === void 0 ? void 0 : transform.out)) {
+        const transformFn = () => {
             if (fieldTransforms) {
                 const { obj, path: pathTransformed } = transformObjectWithPath(value, path, pathTypes, fieldTransforms);
                 value = obj;
@@ -155,30 +173,30 @@ function adjustSaveData(value, path, pathTypes, { adjustData, fieldTransforms, }
             }
             return { value, path };
         };
-        if (adjustData === null || adjustData === void 0 ? void 0 : adjustData.save) {
+        if (transform === null || transform === void 0 ? void 0 : transform.out) {
             const constructed = state.constructObjectWithPath(path, value, pathTypes);
-            const saved = adjustData.save(constructed);
+            const saved = transform.out(constructed);
             const deconstruct = (toDeconstruct) => {
                 value = state.deconstructObjectWithPath(path, toDeconstruct);
-                return transform();
+                return transformFn();
             };
             return doInOrder(saved, deconstruct);
         }
-        return transform();
+        return transformFn();
     }
     return { value, path };
 }
-function adjustLoadData(value, { adjustData, fieldTransforms, }, doUserAdjustData) {
+function transformLoadData(value, { transform, fieldTransforms }, doUserTransform) {
     if (fieldTransforms) {
         const inverted = invertFieldMap(fieldTransforms);
         value = transformObject(value, inverted);
     }
-    if (doUserAdjustData && (adjustData === null || adjustData === void 0 ? void 0 : adjustData.load)) {
-        value = adjustData.load(value);
+    if (doUserTransform && (transform === null || transform === void 0 ? void 0 : transform.in)) {
+        value = transform.in(value);
     }
     return value;
 }
-async function updateMetadataImmediate(obs, localState, obsState, persistOptions, newMetadata) {
+async function updateMetadataImmediate(obs, localState, syncState, persistOptions, newMetadata) {
     const saves = Array.from(promisesLocalSaves);
     if (saves.length > 0) {
         await Promise.all(saves);
@@ -193,17 +211,19 @@ async function updateMetadataImmediate(obs, localState, obsState, persistOptions
     if (needsUpdate) {
         const metadata = Object.assign({}, oldMetadata, newMetadata);
         metadatas.set(obs, metadata);
-        await persistenceLocal.updateMetadata(table, metadata, config);
+        if (persistenceLocal) {
+            await persistenceLocal.setMetadata(table, metadata, config);
+        }
         if (modified) {
-            obsState.dateModified.set(modified);
+            syncState.dateModified.set(modified);
         }
     }
 }
-function updateMetadata(obs, localState, obsState, persistOptions, newMetadata) {
+function updateMetadata(obs, localState, syncState, persistOptions, newMetadata) {
     if (localState.timeoutSaveMetadata) {
         clearTimeout(localState.timeoutSaveMetadata);
     }
-    localState.timeoutSaveMetadata = setTimeout(() => updateMetadataImmediate(obs, localState, obsState, persistOptions, newMetadata), 30);
+    localState.timeoutSaveMetadata = setTimeout(() => updateMetadataImmediate(obs, localState, syncState, persistOptions, newMetadata), 30);
 }
 let _queuedChanges = [];
 async function processQueuedChanges() {
@@ -211,9 +231,9 @@ async function processQueuedChanges() {
     const queuedChanges = _queuedChanges;
     _queuedChanges = [];
     // 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 adjustData.
+    // 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 adjustSaveData than others.
+    // since some may take longer to transformSaveData than others.
     const changes = await Promise.all(queuedChanges.map(prepChange));
     // 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.
@@ -227,21 +247,22 @@ async function processQueuedChanges() {
     changes.forEach(doChange);
 }
 async function prepChange(queuedChange) {
-    const { obsState, changes, localState, persistOptions, inRemoteChange, isApplyingPending } = queuedChange;
+    const { syncState, changes, localState, persistOptions, inRemoteChange, isApplyingPending } = queuedChange;
     const local = persistOptions.local;
+    const { persistenceRemote } = localState;
     const { config: configLocal } = parseLocalConfig(local);
     const configRemote = persistOptions.remote;
-    const saveLocal = local && !configLocal.readonly && !isApplyingPending && obsState.isEnabledLocal.peek();
-    const saveRemote = !inRemoteChange && configRemote && !configRemote.readonly && obsState.isEnabledRemote.peek();
+    const saveLocal = local && !configLocal.readonly && !isApplyingPending && syncState.isEnabledLocal.peek();
+    const saveRemote = !inRemoteChange && persistenceRemote && !(configRemote === null || configRemote === void 0 ? void 0 : configRemote.readonly) && syncState.isEnabledRemote.peek();
     if (saveLocal || saveRemote) {
-        if (saveLocal && !obsState.isLoadedLocal.peek()) {
+        if (saveLocal && !syncState.isLoadedLocal.peek()) {
             console.error('[legend-state] WARNING: An observable was changed before being loaded from persistence', local);
             return;
         }
         const changesLocal = [];
         const changesRemote = [];
         const changesPaths = new Set();
-        let promisesAdjustData = [];
+        let promisesTransform = [];
         // Reverse order
         for (let i = changes.length - 1; i >= 0; i--) {
             const { path } = changes[i];
@@ -263,26 +284,26 @@ async function prepChange(queuedChange) {
                 changesPaths.add(pathStr);
                 const { prevAtPath, valueAtPath, pathTypes } = changes[i];
                 if (saveLocal) {
-                    const promiseAdjustLocal = adjustSaveData(valueAtPath, path, pathTypes, configLocal);
-                    promisesAdjustData.push(doInOrder(promiseAdjustLocal, ({ path: pathAdjusted, value: valueAdjusted }) => {
+                    const promiseTransformLocal = transformOutData(valueAtPath, path, pathTypes, configLocal);
+                    promisesTransform.push(doInOrder(promiseTransformLocal, ({ path: pathTransformed, value: valueTransformed }) => {
                         // If path includes undefined there was a null in fieldTransforms so don't need to save it
-                        if (!pathAdjusted.includes(undefined)) {
-                            // Prepare the local change with the adjusted path/value
+                        if (!pathTransformed.includes(undefined)) {
+                            // Prepare the local change with the transformed path/value
                             changesLocal.push({
-                                path: pathAdjusted,
+                                path: pathTransformed,
                                 pathTypes,
                                 prevAtPath,
-                                valueAtPath: valueAdjusted,
+                                valueAtPath: valueTransformed,
                                 pathStr,
                             });
                         }
                     }));
                 }
                 if (saveRemote) {
-                    const promiseAdjustRemote = adjustSaveData(valueAtPath, path, pathTypes, configRemote);
-                    promisesAdjustData.push(doInOrder(promiseAdjustRemote, ({ path: pathAdjusted, value: valueAdjusted }) => {
+                    const promiseTransformRemote = transformOutData(valueAtPath, path, pathTypes, configRemote || {});
+                    promisesTransform.push(doInOrder(promiseTransformRemote, ({ path: pathTransformed, value: valueTransformed }) => {
                         // If path includes undefined there was a null in fieldTransforms so don't need to save it
-                        if (!pathAdjusted.includes(undefined)) {
+                        if (!pathTransformed.includes(undefined)) {
                             // Prepare pending changes
                             if (!localState.pendingChanges) {
                                 localState.pendingChanges = {};
@@ -292,15 +313,15 @@ async function prepChange(queuedChange) {
                             if (!localState.pendingChanges[pathStr]) {
                                 localState.pendingChanges[pathStr] = { p: prevAtPath !== null && prevAtPath !== void 0 ? prevAtPath : null, t: pathTypes };
                             }
-                            // Pending value is the unadjusted value because it gets loaded without adjustment
-                            // and forwarded through to onObsChange where it gets adjusted before save
+                            // 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 adjusted path/value
+                            // Prepare the remote change with the transformed path/value
                             changesRemote.push({
-                                path: pathAdjusted,
+                                path: pathTransformed,
                                 pathTypes,
                                 prevAtPath,
-                                valueAtPath: valueAdjusted,
+                                valueAtPath: valueTransformed,
                                 pathStr,
                             });
                         }
@@ -308,27 +329,28 @@ async function prepChange(queuedChange) {
                 }
             }
         }
-        // If there's any adjustData promises, wait for them before saving
-        promisesAdjustData = promisesAdjustData.filter(Boolean);
-        if (promisesAdjustData.length > 0) {
-            await Promise.all(promisesAdjustData);
+        // If there's any transform promises, wait for them before saving
+        promisesTransform = promisesTransform.filter(Boolean);
+        if (promisesTransform.length > 0) {
+            await Promise.all(promisesTransform);
         }
         return { queuedChange, changesLocal, changesRemote };
     }
 }
 async function doChange(changeInfo) {
-    var _a, _b;
+    var _a, _b, _c;
     if (!changeInfo)
         return;
     const { queuedChange, changesLocal, changesRemote } = changeInfo;
-    const { obs, obsState, localState, persistOptions } = queuedChange;
+    const { obs, syncState, localState, persistOptions } = queuedChange;
     const { persistenceLocal, persistenceRemote } = localState;
     const local = persistOptions.local;
     const { table, config: configLocal } = parseLocalConfig(local);
     const configRemote = persistOptions.remote;
-    if (changesRemote.length > 0) {
+    const shouldSaveMetadata = local && (configRemote === null || configRemote === void 0 ? void 0 : configRemote.offlineBehavior) === 'retry';
+    if (changesRemote.length > 0 && shouldSaveMetadata) {
         // First save pending changes before saving local or remote
-        await updateMetadataImmediate(obs, localState, obsState, persistOptions, {
+        await updateMetadataImmediate(obs, localState, syncState, persistOptions, {
             pending: localState.pendingChanges,
         });
     }
@@ -348,74 +370,67 @@ async function doChange(changeInfo) {
     }
     if (changesRemote.length > 0) {
         // Wait for remote to be ready before saving
-        await state.when(() => obsState.isLoadedRemote.get() || (configRemote.allowSaveIfError && obsState.remoteError.get()));
-        const saves = await Promise.all(changesRemote.map(async (change) => {
-            const { path, valueAtPath, prevAtPath, pathTypes, pathStr } = change;
-            // Save to remote persistence
-            return persistenceRemote
-                .save({
-                obs,
-                state: obsState,
-                options: persistOptions,
-                path: path,
-                pathTypes,
-                valueAtPath,
-                prevAtPath,
-            })
-                .then(({ changes, dateModified }) => ({ changes, dateModified, pathStr }));
-        }));
+        await state.when(() => syncState.isLoadedRemote.get() || ((configRemote === null || configRemote === void 0 ? void 0 : configRemote.allowSetIfError) && syncState.remoteError.get()));
+        const value = obs.peek();
+        (_a = configRemote === null || configRemote === void 0 ? void 0 : configRemote.onBeforeSet) === null || _a === void 0 ? void 0 : _a.call(configRemote);
+        const saved = await persistenceRemote.set({
+            obs,
+            syncState: syncState,
+            options: persistOptions,
+            changes: changesRemote,
+            value,
+        }).catch((err) => { var _a; return (_a = configRemote === null || configRemote === void 0 ? void 0 : configRemote.onSetError) === null || _a === void 0 ? void 0 : _a.call(configRemote, err); });
         // If this remote save changed anything then update persistence 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 (saves.filter(Boolean).length > 0) {
-            if (local) {
-                const metadata = {};
-                const pending = (_a = persistenceLocal.getMetadata(table, configLocal)) === null || _a === void 0 ? void 0 : _a.pending;
-                let adjustedChanges = [];
-                for (let i = 0; i < saves.length; i++) {
-                    const save = saves[i];
-                    if (save) {
-                        const { changes, dateModified, pathStr } = save;
+        if (saved) {
+            const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
+            const { changes, dateModified } = saved;
+            if (pathStrs.length > 0) {
+                if (local) {
+                    const metadata = {};
+                    const pending = (_b = persistenceLocal.getMetadata(table, configLocal)) === null || _b === void 0 ? void 0 : _b.pending;
+                    let transformedChanges = [];
+                    for (let i = 0; i < pathStrs.length; i++) {
+                        const pathStr = pathStrs[i];
                         // Clear pending for this path
                         if (pending === null || pending === void 0 ? void 0 : pending[pathStr]) {
-                            // Remove pending from the saved object
-                            delete pending[pathStr];
                             // Remove pending from local state
-                            delete localState.pendingChanges[pathStr];
+                            delete pending[pathStr];
                             metadata.pending = pending;
                         }
-                        if (dateModified) {
-                            metadata.modified = dateModified;
-                        }
-                        // 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)) {
-                            adjustedChanges.push(adjustLoadData(changes, persistOptions.remote, false));
+                    }
+                    if (dateModified) {
+                        metadata.modified = dateModified;
+                    }
+                    // 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.push(transformLoadData(changes, persistOptions.remote, false));
+                    }
+                    if (transformedChanges.length > 0) {
+                        if (transformedChanges.some((change) => state.isPromise(change))) {
+                            transformedChanges = await Promise.all(transformedChanges);
                         }
+                        onChangeRemote(() => state.mergeIntoObservable(obs, ...transformedChanges));
                     }
-                }
-                if (adjustedChanges.length > 0) {
-                    if (adjustedChanges.some((change) => state.isPromise(change))) {
-                        adjustedChanges = await Promise.all(adjustedChanges);
+                    if (shouldSaveMetadata && !state.isEmpty(metadata)) {
+                        updateMetadata(obs, localState, syncState, persistOptions, metadata);
                     }
-                    onChangeRemote(() => state.mergeIntoObservable(obs, ...adjustedChanges));
-                }
-                if (local && !state.isEmpty(metadata)) {
-                    updateMetadata(obs, localState, obsState, persistOptions, metadata);
                 }
+                (_c = configRemote === null || configRemote === void 0 ? void 0 : configRemote.onSet) === null || _c === void 0 ? void 0 : _c.call(configRemote);
             }
-            (_b = localState.onSaveRemote) === null || _b === void 0 ? void 0 : _b.call(localState);
         }
     }
 }
-function onObsChange(obs, obsState, localState, persistOptions, { changes }) {
+function onObsChange(obs, syncState, localState, persistOptions, { changes }) {
     if (!state.internal.globalState.isLoadingLocal) {
         const inRemoteChange = state.internal.globalState.isLoadingRemote;
         const isApplyingPending = localState.isApplyingPending;
         // Queue changes in a microtask so that multiple changes within a frame get run together
         _queuedChanges.push({
             obs: obs,
-            obsState,
+            syncState,
             localState,
             persistOptions,
             changes,
@@ -438,10 +453,10 @@ function onChangeRemote(cb) {
         });
     });
 }
-async function loadLocal(obs, persistOptions, obsState, localState) {
-    var _a, _b;
+async function loadLocal(obs, persistOptions, syncState, localState) {
+    var _a;
     const { local } = persistOptions;
-    const localPersistence = persistOptions.persistLocal || observablePersistConfiguration.persistLocal;
+    const localPersistence = persistOptions.pluginLocal || observablePersistConfiguration.pluginLocal;
     if (local) {
         const { table, config } = parseLocalConfig(local);
         if (!localPersistence) {
@@ -453,7 +468,7 @@ async function loadLocal(obs, persistOptions, obsState, localState) {
             const mapValue = { persist: persistenceLocal, initialized: state.observable(false) };
             mapPersistences.set(localPersistence, mapValue);
             if (persistenceLocal.initialize) {
-                const initializePromise = (_a = persistenceLocal.initialize) === null || _a === void 0 ? void 0 : _a.call(persistenceLocal, observablePersistConfiguration.persistLocalOptions);
+                const initializePromise = (_a = persistenceLocal.initialize) === null || _a === void 0 ? void 0 : _a.call(persistenceLocal, observablePersistConfiguration.localOptions || {});
                 if (state.isPromise(initializePromise)) {
                     await initializePromise;
                 }
@@ -478,20 +493,12 @@ async function loadLocal(obs, persistOptions, obsState, localState) {
         if (metadata) {
             metadatas.set(obs, metadata);
             localState.pendingChanges = metadata.pending;
-            obsState.dateModified.set(metadata.modified);
+            syncState.dateModified.set(metadata.modified);
         }
         // Merge the data from local persistence into the default state
         if (value !== null && value !== undefined) {
-            // eslint-disable-next-line prefer-const
-            let { adjustData, fieldTransforms } = config;
-            if (fieldTransforms) {
-                const valueLoaded = (_b = persistenceLocal.getTableTransformed) === null || _b === void 0 ? void 0 : _b.call(persistenceLocal, table, config);
-                if (valueLoaded) {
-                    value = valueLoaded;
-                    fieldTransforms = undefined;
-                }
-            }
-            value = adjustLoadData(value, { adjustData, fieldTransforms }, true);
+            const { transform, fieldTransforms } = config;
+            value = transformLoadData(value, { transform, fieldTransforms }, true);
             if (state.isPromise(value)) {
                 value = await value;
             }
@@ -505,18 +512,26 @@ async function loadLocal(obs, persistOptions, obsState, localState) {
                 state.internal.globalState.isLoadingLocal = false;
             });
         }
-        obsState.peek().clearLocal = () => Promise.all([
+        syncState.peek().clearLocal = () => Promise.all([
             persistenceLocal.deleteTable(table, config),
             persistenceLocal.deleteMetadata(table, config),
         ]);
     }
-    obsState.isLoadedLocal.set(true);
+    syncState.isLoadedLocal.set(true);
 }
-function persistObservable(obs, persistOptions) {
-    const { remote, local } = persistOptions;
-    const remotePersistence = persistOptions.persistRemote || (observablePersistConfiguration === null || observablePersistConfiguration === void 0 ? void 0 : observablePersistConfiguration.persistRemote);
+function persistObservable(initialOrObservable, persistOptions) {
+    const obs = (state.isObservable(initialOrObservable)
+        ? initialOrObservable
+        : state.observable(state.isFunction(initialOrObservable) ? initialOrObservable() : initialOrObservable));
+    // Merge remote persist options with clobal options
+    if (persistOptions.remote) {
+        persistOptions.remote = Object.assign({}, observablePersistConfiguration.remoteOptions, persistOptions.remote);
+    }
+    let { remote } = persistOptions;
+    const { local } = persistOptions;
+    const remotePersistence = persistOptions.pluginRemote || (observablePersistConfiguration === null || observablePersistConfiguration === void 0 ? void 0 : observablePersistConfiguration.pluginRemote);
     const localState = {};
-    const obsState = state.observable({
+    const syncState = state.observable({
         isLoadedLocal: false,
         isLoadedRemote: false,
         isEnabledLocal: true,
@@ -526,37 +541,47 @@ function persistObservable(obs, persistOptions) {
         getPendingChanges: () => localState.pendingChanges,
     });
     if (local) {
-        loadLocal(obs, persistOptions, obsState, localState);
+        loadLocal(obs, persistOptions, syncState, localState);
     }
-    if (remote) {
+    if (remote || remotePersistence) {
         if (!remotePersistence) {
             throw new Error('Remote persistence is not configured');
         }
-        // Ensure there's only one instance of the persistence plugin
-        if (!mapPersistences.has(remotePersistence)) {
-            mapPersistences.set(remotePersistence, { persist: new remotePersistence() });
+        if (!remote) {
+            remote = {};
+        }
+        if (state.isObject(remotePersistence)) {
+            localState.persistenceRemote = observablePersistRemoteFunctionsAdapter(remotePersistence);
+        }
+        else {
+            // Ensure there's only one instance of the persistence plugin
+            if (!mapPersistences.has(remotePersistence)) {
+                mapPersistences.set(remotePersistence, {
+                    persist: new remotePersistence(),
+                });
+            }
+            localState.persistenceRemote = mapPersistences.get(remotePersistence)
+                .persist;
         }
-        localState.persistenceRemote = mapPersistences.get(remotePersistence).persist;
         let isSynced = false;
         const sync = async () => {
-            var _a, _b;
+            var _a;
             if (!isSynced) {
                 isSynced = true;
-                localState.onSaveRemote = (_a = persistOptions.remote) === null || _a === void 0 ? void 0 : _a.onSaveRemote;
-                const dateModified = (_b = metadatas.get(obs)) === null || _b === void 0 ? void 0 : _b.modified;
-                localState.persistenceRemote.listen({
-                    state: obsState,
+                const dateModified = (_a = metadatas.get(obs)) === null || _a === void 0 ? void 0 : _a.modified;
+                localState.persistenceRemote.get({
+                    state: syncState,
                     obs,
                     options: persistOptions,
                     dateModified,
-                    onLoad: () => {
-                        obsState.isLoadedRemote.set(true);
+                    onGet: () => {
+                        syncState.isLoadedRemote.set(true);
                     },
-                    onChange: async ({ value, path, pathTypes, mode, dateModified }) => {
+                    onChange: async ({ value, path = [], pathTypes = [], mode = 'set', dateModified }) => {
                         // Note: value is the constructed value, path is used for setInObservableAtPath
                         // to start the set into the observable from the path
                         if (value !== undefined) {
-                            value = adjustLoadData(value, remote, true);
+                            value = transformLoadData(value, remote, true);
                             if (state.isPromise(value)) {
                                 value = await value;
                             }
@@ -577,14 +602,16 @@ function persistObservable(obs, persistOptions) {
                                     Object.keys(pending).forEach((key) => {
                                         const p = key.split('/').filter((p) => p !== '');
                                         const { v, t } = pending[key];
-                                        value = state.setAtPath(value, p, t, v, obs.peek(), (path, value) => {
-                                            delete pending[key];
-                                            pending[path.join('/')] = {
-                                                p: null,
-                                                v: value,
-                                                t: t.slice(0, path.length),
-                                            };
-                                        });
+                                        if (value[p[0]] !== undefined) {
+                                            value = state.setAtPath(value, p, t, v, obs.peek(), (path, value) => {
+                                                delete pending[key];
+                                                pending[path.join('/')] = {
+                                                    p: null,
+                                                    v: value,
+                                                    t: t.slice(0, path.length),
+                                                };
+                                            });
+                                        }
                                     });
                                 }
                                 onChangeRemote(() => {
@@ -593,14 +620,14 @@ function persistObservable(obs, persistOptions) {
                             }
                         }
                         if (dateModified && local) {
-                            updateMetadata(obs, localState, obsState, persistOptions, {
+                            updateMetadata(obs, localState, syncState, persistOptions, {
                                 modified: dateModified,
                             });
                         }
                     },
                 });
                 // Wait for remote to be ready before saving pending
-                await state.when(() => obsState.isLoadedRemote.get() || (remote.allowSaveIfError && obsState.remoteError.get()));
+                await state.when(() => syncState.isLoadedRemote.get() || (remote.allowSetIfError && syncState.remoteError.get()));
                 const pending = localState.pendingChanges;
                 if (pending && !state.isEmpty(pending)) {
                     localState.isApplyingPending = true;
@@ -614,7 +641,7 @@ function persistObservable(obs, persistOptions) {
                         changes.push({ path, valueAtPath: v, prevAtPath: p, pathTypes: t });
                     }
                     // Send the changes into onObsChange so that they get persisted remotely
-                    onObsChange(obs, obsState, localState, persistOptions, {
+                    onObsChange(obs, syncState, localState, persistOptions, {
                         value: obs.peek(),
                         // TODO getPrevious if any remote persistence layers need it
                         getPrevious: () => undefined,
@@ -625,16 +652,16 @@ function persistObservable(obs, persistOptions) {
             }
         };
         if (remote.manual) {
-            obsState.assign({ sync });
+            syncState.assign({ sync });
         }
         else {
-            state.when(() => !local || obsState.isLoadedLocal.get(), sync);
+            state.when(() => !local || syncState.isLoadedLocal.get(), sync);
         }
     }
-    state.when(obsState.isLoadedLocal, function () {
-        obs.onChange(onObsChange.bind(this, obs, obsState, localState, persistOptions));
+    state.when(!local || syncState.isLoadedLocal, function () {
+        obs.onChange(onObsChange.bind(this, obs, syncState, localState, persistOptions));
     });
-    return obsState;
+    return [obs, syncState];
 }
 
 function isInRemoteChange() {