@legendapp/state 2.0.0-next.9 → 2.0.0

package/persist.mjs

@@ -1,4 +1,4 @@
-import { symbolDelete, isString, isArray, isObject, constructObjectWithPath, deconstructObjectWithPath, observable, when, internal as internal$1, batch, isPromise, mergeIntoObservable, isEmpty, setInObservableAtPath, setAtPath } from '@legendapp/state';
+import { symbolDelete, isString, isArray, isObject, constructObjectWithPath, deconstructObjectWithPath, observable, when, internal as internal$1, batch, isObservable, isFunction, isPromise, mergeIntoObservable, isEmpty, setInObservableAtPath, setAtPath } from '@legendapp/state';
 
 const observablePersistConfiguration = {};
 function configureObservablePersistence(options) {
@@ -133,17 +133,18 @@ if (process.env.NODE_ENV === 'development') {
     };
 }
 
-function observablePersistRemoteSimple({ get, set }) {
-    return {
-        async get({ dateModified, onChange, onLoad }) {
-            const value = (await get({ dateModified }));
-            onChange({ value, dateModified: Date.now() });
-            onLoad();
-        },
-        async save({ valueAtPath, prevAtPath, path, pathTypes, value }) {
-            return set ? set({ valueAtPath, path, pathTypes, prevAtPath, value }) : {};
+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();
@@ -160,9 +161,9 @@ function parseLocalConfig(config) {
 function doInOrder(arg1, arg2) {
     return 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;
@@ -170,30 +171,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 = constructObjectWithPath(path, value, pathTypes);
-            const saved = adjustData.save(constructed);
+            const saved = transform.out(constructed);
             const deconstruct = (toDeconstruct) => {
                 value = 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);
@@ -209,18 +210,18 @@ async function updateMetadataImmediate(obs, localState, obsState, persistOptions
         const metadata = Object.assign({}, oldMetadata, newMetadata);
         metadatas.set(obs, metadata);
         if (persistenceLocal) {
-            await persistenceLocal.updateMetadata(table, metadata, config);
+            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() {
@@ -228,9 +229,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.
@@ -244,21 +245,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];
@@ -280,44 +282,65 @@ 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 = {};
                             }
-                            // 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 };
+                            // First look for existing pending changes at a higher level than this change
+                            // If they exist then merge this change into it
+                            const split = pathStr.split('/');
+                            let found = false;
+                            for (let i = 0; !found && i < split.length - 1; i++) {
+                                const pathParent = split.slice(0, i + 1).join('/');
+                                if (localState.pendingChanges[pathParent]) {
+                                    found = true;
+                                    const pathChild = split.slice(i + 1);
+                                    setAtPath(localState.pendingChanges[pathParent].v, pathChild, [], 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;
                             }
-                            // Pending value is the unadjusted value because it gets loaded without adjustment
-                            // and forwarded through to onObsChange where it gets adjusted 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,
                             });
                         }
@@ -325,27 +348,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,
         });
     }
@@ -365,76 +389,67 @@ async function doChange(changeInfo) {
     }
     if (changesRemote.length > 0) {
         // Wait for remote to be ready before saving
-        await when(() => obsState.isLoadedRemote.get() || (configRemote.allowSaveIfError && obsState.remoteError.get()));
+        await when(() => syncState.isLoadedRemote.get() || ((configRemote === null || configRemote === void 0 ? void 0 : configRemote.allowSetIfError) && syncState.remoteError.get()));
         const value = obs.peek();
-        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,
-                value,
-            })
-                .then(({ changes, dateModified }) => ({ changes, dateModified, pathStr }));
-        }));
+        (_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 && !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 && !isEmpty(changes)) {
+                        transformedChanges.push(transformLoadData(changes, persistOptions.remote, false));
+                    }
+                    if (transformedChanges.length > 0) {
+                        if (transformedChanges.some((change) => isPromise(change))) {
+                            transformedChanges = await Promise.all(transformedChanges);
                         }
+                        onChangeRemote(() => mergeIntoObservable(obs, ...transformedChanges));
                     }
-                }
-                if (adjustedChanges.length > 0) {
-                    if (adjustedChanges.some((change) => isPromise(change))) {
-                        adjustedChanges = await Promise.all(adjustedChanges);
+                    if (shouldSaveMetadata && !isEmpty(metadata)) {
+                        updateMetadata(obs, localState, syncState, persistOptions, metadata);
                     }
-                    onChangeRemote(() => mergeIntoObservable(obs, ...adjustedChanges));
-                }
-                if (local && !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 (!internal$1.globalState.isLoadingLocal) {
         const inRemoteChange = internal$1.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,
@@ -457,10 +472,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) {
@@ -472,7 +487,7 @@ async function loadLocal(obs, persistOptions, obsState, localState) {
             const mapValue = { persist: persistenceLocal, initialized: 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 (isPromise(initializePromise)) {
                     await initializePromise;
                 }
@@ -497,20 +512,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 (isPromise(value)) {
                 value = await value;
             }
@@ -524,19 +531,26 @@ async function loadLocal(obs, persistOptions, obsState, localState) {
                 internal$1.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) {
+function persistObservable(initialOrObservable, persistOptions) {
+    const obs = (isObservable(initialOrObservable)
+        ? initialOrObservable
+        : observable(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.persistRemote || (observablePersistConfiguration === null || observablePersistConfiguration === void 0 ? void 0 : observablePersistConfiguration.persistRemote);
+    const remotePersistence = persistOptions.pluginRemote || (observablePersistConfiguration === null || observablePersistConfiguration === void 0 ? void 0 : observablePersistConfiguration.pluginRemote);
     const localState = {};
-    const obsState = observable({
+    const syncState = observable({
         isLoadedLocal: false,
         isLoadedRemote: false,
         isEnabledLocal: true,
@@ -546,7 +560,7 @@ function persistObservable(obs, persistOptions) {
         getPendingChanges: () => localState.pendingChanges,
     });
     if (local) {
-        loadLocal(obs, persistOptions, obsState, localState);
+        loadLocal(obs, persistOptions, syncState, localState);
     }
     if (remote || remotePersistence) {
         if (!remotePersistence) {
@@ -556,7 +570,7 @@ function persistObservable(obs, persistOptions) {
             remote = {};
         }
         if (isObject(remotePersistence)) {
-            localState.persistenceRemote = observablePersistRemoteSimple(remotePersistence);
+            localState.persistenceRemote = observablePersistRemoteFunctionsAdapter(remotePersistence);
         }
         else {
             // Ensure there's only one instance of the persistence plugin
@@ -565,28 +579,28 @@ function persistObservable(obs, persistOptions) {
                     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;
+                const dateModified = (_a = metadatas.get(obs)) === null || _a === void 0 ? void 0 : _a.modified;
                 localState.persistenceRemote.get({
-                    state: obsState,
+                    state: syncState,
                     obs,
                     options: persistOptions,
                     dateModified,
-                    onLoad: () => {
-                        obsState.isLoadedRemote.set(true);
+                    onGet: () => {
+                        syncState.isLoadedRemote.set(true);
                     },
                     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 (isPromise(value)) {
                                 value = await value;
                             }
@@ -625,14 +639,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 when(() => obsState.isLoadedRemote.get() || (remote.allowSaveIfError && obsState.remoteError.get()));
+                await when(() => syncState.isLoadedRemote.get() || (remote.allowSetIfError && syncState.remoteError.get()));
                 const pending = localState.pendingChanges;
                 if (pending && !isEmpty(pending)) {
                     localState.isApplyingPending = true;
@@ -646,7 +660,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,
@@ -657,16 +671,16 @@ function persistObservable(obs, persistOptions) {
             }
         };
         if (remote.manual) {
-            obsState.assign({ sync });
+            syncState.assign({ sync });
         }
         else {
-            when(() => !local || obsState.isLoadedLocal.get(), sync);
+            when(() => !local || syncState.isLoadedLocal.get(), sync);
         }
     }
-    when(!local || obsState.isLoadedLocal, function () {
-        obs.onChange(onObsChange.bind(this, obs, obsState, localState, persistOptions));
+    when(!local || syncState.isLoadedLocal, function () {
+        obs.onChange(onObsChange.bind(this, obs, syncState, localState, persistOptions));
     });
-    return obsState;
+    return [obs, syncState];
 }
 
 function isInRemoteChange() {