@legendapp/state 0.23.2 → 1.0.0-rc.2

package/persist.mjs

@@ -1,17 +1,18 @@
-import { isObject, observable, when, tracking as tracking$1, symbolDateModified, dateModifiedKey, constructObject, clone, deconstructObject, isEmpty, mergeIntoObservable, beginBatch, endBatch, batch, isString } from '@legendapp/state';
+import { symbolDelete, symbolDateModified, isObject, isString, constructObjectWithPath, dateModifiedKey, deconstructObjectWithPath, isArray, observable, tracking as tracking$1, beginBatch, endBatch, when, isSymbol, isPromise, isEmpty, batch, mergeIntoObservable, setInObservableAtPath } from '@legendapp/state';
 
 const observablePersistConfiguration = {};
 function configureObservablePersistence(options) {
     Object.assign(observablePersistConfiguration, options);
 }
 
-function transformPath(path, map, passThroughKeys, ignoreKeys) {
+let validateMap;
+function transformPath(path, map, passThroughKeys) {
     const data = {};
     let d = data;
     for (let i = 0; i < path.length; i++) {
         d = d[path[i]] = i === path.length - 1 ? null : {};
     }
-    let value = transformObject(data, map, passThroughKeys, ignoreKeys);
+    let value = transformObject(data, map, passThroughKeys);
     const pathOut = [];
     for (let i = 0; i < path.length; i++) {
         const key = Object.keys(value)[0];
@@ -21,11 +22,20 @@ function transformPath(path, map, passThroughKeys, ignoreKeys) {
     return pathOut;
 }
 function transformObject(dataIn, map, passThroughKeys, ignoreKeys) {
+    if (process.env.NODE_ENV === 'development') {
+        validateMap(map);
+    }
     // Note: If changing this, change it in IndexedDB preloader
     let ret = dataIn;
     if (dataIn) {
+        if (dataIn === symbolDelete)
+            return dataIn;
         ret = {};
         const dict = Object.keys(map).length === 1 && map['_dict'];
+        let dateModified = dataIn[symbolDateModified];
+        if (dateModified) {
+            ret[symbolDateModified] = dateModified;
+        }
         Object.keys(dataIn).forEach((key) => {
             if (ret[key] !== undefined || (ignoreKeys === null || ignoreKeys === void 0 ? void 0 : ignoreKeys.includes(key)))
                 return;
@@ -47,14 +57,24 @@ function transformObject(dataIn, map, passThroughKeys, ignoreKeys) {
                 }
                 else if (mapped !== null) {
                     if (v !== undefined && v !== null) {
-                        if (map[key + '_obj']) {
+                        if (map[key + '_val']) {
+                            const valMap = map[key + '_val'];
+                            v = valMap[key];
+                        }
+                        else if (map[key + '_obj']) {
                             v = transformObject(v, map[key + '_obj'], passThroughKeys, ignoreKeys);
                         }
                         else if (map[key + '_dict']) {
                             const mapChild = map[key + '_dict'];
+                            let out = {};
+                            let dateModifiedChild = dataIn[symbolDateModified];
+                            if (dateModifiedChild) {
+                                out[symbolDateModified] = dateModifiedChild;
+                            }
                             Object.keys(v).forEach((keyChild) => {
-                                v[keyChild] = transformObject(v[keyChild], mapChild, passThroughKeys, ignoreKeys);
+                                out[keyChild] = transformObject(v[keyChild], mapChild, passThroughKeys, ignoreKeys);
                             });
+                            v = out;
                         }
                         else if (map[key + '_arr']) {
                             const mapChild = map[key + '_arr'];
@@ -72,8 +92,14 @@ function transformObject(dataIn, map, passThroughKeys, ignoreKeys) {
         debugger;
     return ret;
 }
+function transformObjectWithPath(obj, path, pathTypes, fieldTransforms) {
+    let constructed = constructObjectWithPath(path, obj, pathTypes);
+    const transformed = transformObject(constructed, fieldTransforms, [dateModifiedKey]);
+    const transformedPath = transformPath(path, fieldTransforms, [dateModifiedKey]);
+    return { path: transformedPath, obj: deconstructObjectWithPath(transformedPath, transformed) };
+}
 const invertedMaps = new WeakMap();
-function invertMap(obj) {
+function invertFieldMap(obj) {
     // Note: If changing this, change it in IndexedDB preloader
     const existing = invertedMaps.get(obj);
     if (existing)
@@ -84,12 +110,12 @@ function invertMap(obj) {
         if (process.env.NODE_ENV === 'development' && target[val])
             debugger;
         if (key === '_dict') {
-            target[key] = invertMap(val);
+            target[key] = invertFieldMap(val);
         }
         else if (key.endsWith('_obj') || key.endsWith('_dict') || key.endsWith('_arr')) {
             const keyMapped = obj[key.replace(/_obj|_dict|_arr$/, '')];
             const suffix = key.match(/_obj|_dict|_arr$/)[0];
-            target[keyMapped + suffix] = invertMap(val);
+            target[keyMapped + suffix] = invertFieldMap(val);
         }
         else if (typeof val === 'string') {
             target[val] = key;
@@ -100,21 +126,25 @@ function invertMap(obj) {
     invertedMaps.set(obj, target);
     return target;
 }
-
-function removeNullUndefined(val) {
-    if (val === undefined)
-        return null;
-    Object.keys(val).forEach((key) => {
-        const v = val[key];
-        if (v === null || v === undefined) {
-            delete val[key];
-        }
-        else if (isObject(v)) {
-            removeNullUndefined(v);
+if (process.env.NODE_ENV === 'development') {
+    validateMap = function (record) {
+        const values = Object.values(record).filter((value) => {
+            if (isObject(value)) {
+                validateMap(value);
+            }
+            else {
+                return isString(value);
+            }
+        });
+        const uniques = Array.from(new Set(values));
+        if (values.length !== uniques.length) {
+            console.error('Field transform map has duplicate values', record, values.length, uniques.length);
+            debugger;
         }
-    });
-    return val;
+        return record;
+    };
 }
+
 function replaceKeyInObject(obj, keySource, keyTarget, clone) {
     if (isObject(obj)) {
         const target = clone ? {} : obj;
@@ -122,6 +152,9 @@ function replaceKeyInObject(obj, keySource, keyTarget, clone) {
             target[keyTarget] = obj[keySource];
             delete target[keySource];
         }
+        if (keySource !== symbolDateModified && obj[symbolDateModified]) {
+            target[symbolDateModified] = obj[symbolDateModified];
+        }
         Object.keys(obj).forEach((key) => {
             if (key !== keySource) {
                 target[key] = replaceKeyInObject(obj[key], keySource, keyTarget, clone);
@@ -136,59 +169,139 @@ function replaceKeyInObject(obj, keySource, keyTarget, clone) {
 function getDateModifiedKey(dateModifiedKey) {
     return dateModifiedKey || observablePersistConfiguration.dateModifiedKey || '@';
 }
+function mergeDateModified(obs, source) {
+    const isArr = isArray(source);
+    const isObj = !isArr && isObject(source);
+    let dateModified = isObj && source[symbolDateModified];
+    if (dateModified) {
+        delete source[symbolDateModified];
+    }
+    if (isArr || isObj) {
+        const keys = isArr ? source : Object.keys(source);
+        for (let i = 0; i < keys.length; i++) {
+            const key = isArr ? i : keys[i];
+            dateModified = Math.max(dateModified || 0, mergeDateModified(obs[key], source[key]));
+        }
+    }
+    if (dateModified) {
+        obs.peek()[symbolDateModified] = dateModified;
+    }
+    return dateModified || 0;
+}
 
 const mapPersistences = new WeakMap();
 const persistState = observable({ inRemoteSync: false });
 function parseLocalConfig(config) {
     return isString(config) ? { table: config, config: { name: config } } : { table: config.name, config };
 }
-async function onObsChange(obs, obsState, localState, persistOptions, value, getPrevious, changes) {
-    const { persistenceLocal, persistenceRemote } = localState;
+let isMergingLocalData = false;
+function adjustSaveData(value, path, pathTypes, { adjustData, fieldTransforms, }, replaceKey) {
+    let cloned = replaceKey ? replaceKeyInObject(value, symbolDateModified, dateModifiedKey, /*clone*/ true) : value;
+    const transform = () => {
+        if (fieldTransforms) {
+            const { obj, path: pathTransformed } = transformObjectWithPath(cloned, path, pathTypes, fieldTransforms);
+            cloned = obj;
+            path = pathTransformed;
+        }
+        return { value: cloned, path };
+    };
+    let promise;
+    if (adjustData === null || adjustData === void 0 ? void 0 : adjustData.save) {
+        const constructed = constructObjectWithPath(path, cloned, pathTypes);
+        promise = adjustData.save(constructed);
+    }
+    return isPromise(promise)
+        ? promise.then((adjusted) => {
+            cloned = deconstructObjectWithPath(path, adjusted);
+            return transform();
+        })
+        : transform();
+}
+function adjustLoadData(value, { adjustData, fieldTransforms, }, replaceKey) {
+    let cloned = replaceKey ? replaceKeyInObject(value, dateModifiedKey, symbolDateModified, /*clone*/ true) : value;
+    if (fieldTransforms) {
+        const inverted = invertFieldMap(fieldTransforms);
+        cloned = transformObject(cloned, inverted, [dateModifiedKey]);
+    }
+    if (adjustData === null || adjustData === void 0 ? void 0 : adjustData.load) {
+        cloned = adjustData.load(cloned);
+    }
+    return cloned;
+}
+async function onObsChange(obs, obsState, localState, persistOptions, { value, changes }) {
+    var _a;
+    const { persistenceLocal, persistenceRemote, isApplyingPending } = localState;
     const local = persistOptions.local;
     const { table, config } = parseLocalConfig(local);
+    const configRemote = persistOptions.remote;
     const inRemoteChange = tracking$1.inRemoteChange;
-    const saveRemote = !inRemoteChange && persistOptions.remote && !persistOptions.remote.readonly && obsState.isEnabledRemote.peek();
-    if (local && obsState.isEnabledLocal.peek()) {
+    const saveRemote = !isMergingLocalData &&
+        !inRemoteChange &&
+        configRemote &&
+        !configRemote.readonly &&
+        obsState.isEnabledRemote.peek();
+    const isQueryingModified = !!((_a = configRemote === null || configRemote === void 0 ? void 0 : configRemote.firebase) === null || _a === void 0 ? void 0 : _a.queryByModified);
+    if (local && !config.readonly && !isApplyingPending && obsState.isEnabledLocal.peek()) {
         if (!obsState.isLoadedLocal.peek()) {
             console.error('[legend-state] WARNING: An observable was changed before being loaded from persistence', local);
             return;
         }
-        // If saving remotely convert symbolDateModified to dateModifiedKey before saving locally
-        // as persisting may not include symbols correctly
-        let localValue = value;
-        if (persistOptions.remote) {
-            if (saveRemote) {
-                for (let i = 0; i < changes.length; i++) {
-                    const { path, valueAtPath, prevAtPath } = changes[i];
-                    if (path[path.length - 1] === symbolDateModified)
-                        continue;
-                    const pathStr = path.join('/');
-                    if (!localState.pendingChanges) {
-                        localState.pendingChanges = {};
-                    }
-                    // The value 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 };
-                    }
-                    localState.pendingChanges[pathStr].v = valueAtPath;
+        // Prepare pending changes
+        if (saveRemote) {
+            for (let i = 0; i < changes.length; i++) {
+                const { path, valueAtPath, prevAtPath, pathTypes } = changes[i];
+                if (path[path.length - 1] === symbolDateModified)
+                    continue;
+                const pathStr = path.join('/');
+                if (!localState.pendingChanges) {
+                    localState.pendingChanges = {};
                 }
+                // The value 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 };
+                }
+                localState.pendingChanges[pathStr].v = valueAtPath;
             }
         }
-        let changesLocal = changes;
-        if (config.fieldTransforms) {
-            localValue = transformObject(localValue, config.fieldTransforms, [dateModifiedKey]);
-            changesLocal = changesLocal.map(({ path, prevAtPath, valueAtPath }) => {
-                let transformed = constructObject(path, clone(valueAtPath));
-                transformed = transformObject(transformed, config.fieldTransforms, [dateModifiedKey]);
-                const transformedPath = transformPath(path, config.fieldTransforms, [dateModifiedKey]);
-                const toSave = deconstructObject(transformedPath, transformed);
-                return { path, prevAtPath, valueAtPath: toSave };
-            });
+        // Save changes locally
+        const changesLocal = [];
+        const changesPaths = new Set();
+        const promises = [];
+        changes.forEach((_, i) => {
+            // Reverse order
+            let { path: pathOriginal, prevAtPath, valueAtPath, pathTypes } = changes[changes.length - 1 - i];
+            if (isSymbol(pathOriginal[pathOriginal.length - 1])) {
+                return;
+            }
+            if (isQueryingModified) {
+                pathOriginal = pathOriginal.map((p) => (p === symbolDateModified ? dateModifiedKey : p));
+            }
+            const pathStr = pathOriginal.join('/');
+            // 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 (!changesPaths.has(pathStr)) {
+                changesPaths.add(pathStr);
+                let promise = adjustSaveData(valueAtPath, pathOriginal, pathTypes, config, isQueryingModified);
+                const push = ({ path, value }) => {
+                    changesLocal.push({ path, pathTypes, prevAtPath, valueAtPath: value });
+                };
+                if (isPromise(promise)) {
+                    promises.push(promise.then(push));
+                }
+                else {
+                    push(promise);
+                }
+            }
+        });
+        if (promises.length > 0) {
+            await Promise.all(promises);
         }
-        localValue = replaceKeyInObject(localValue, symbolDateModified, dateModifiedKey, 
-        /*clone*/ true);
-        persistenceLocal.set(table, localValue, changesLocal, config);
+        if (changesLocal.length > 0) {
+            persistenceLocal.set(table, changesLocal, config);
+        }
+        // Save metadata
         const metadata = {};
         if (inRemoteChange) {
             const dateModified = value[symbolDateModified];
@@ -204,49 +317,55 @@ async function onObsChange(obs, obsState, localState, persistOptions, value, get
         }
     }
     if (saveRemote) {
-        await when(obsState.isLoadedRemote);
-        for (let i = 0; i < changes.length; i++) {
-            const { path, valueAtPath, prevAtPath } = changes[i];
+        await when(() => obsState.isLoadedRemote.get() || (configRemote.allowSaveIfError && obsState.remoteError.get()));
+        const fieldTransforms = configRemote.fieldTransforms;
+        changes.forEach(async (change) => {
+            const { path, valueAtPath, prevAtPath, pathTypes } = change;
             if (path[path.length - 1] === symbolDateModified)
-                continue;
+                return;
             const pathStr = path.join('/');
+            const { path: pathSave, value: valueSave } = await adjustSaveData(valueAtPath, path, pathTypes, configRemote, isQueryingModified);
             // Save to remote persistence and get the remote value from it. Some providers (like Firebase) will return a
-            // server value different than the saved value (like Firebase has server timestamps for dateModified)
-            persistenceRemote.save(persistOptions, value, path, valueAtPath, prevAtPath).then((saved) => {
+            // server value with server timestamps for dateModified.
+            persistenceRemote
+                .save({
+                obs,
+                state: obsState,
+                options: persistOptions,
+                path: pathSave,
+                pathTypes,
+                valueAtPath: valueSave,
+                prevAtPath,
+            })
+                .then((saved) => {
                 var _a;
                 if (local) {
-                    let toSave = persistenceLocal.getTable(table, config);
                     const pending = (_a = persistenceLocal.getMetadata(table, config)) === null || _a === void 0 ? void 0 : _a.pending;
-                    let dateModified;
-                    let didDelete = false;
+                    // Clear pending for this path
                     if (pending === null || pending === void 0 ? void 0 : pending[pathStr]) {
-                        didDelete = true;
                         // Remove pending from the saved object
                         delete pending[pathStr];
                         // Remove pending from local state
                         delete localState.pendingChanges[pathStr];
+                        persistenceLocal.updateMetadata(table, { pending }, config);
                     }
                     // Only the latest save will return a value so that it saves back to local persistence once
-                    if (saved !== undefined) {
+                    // It needs to get the dateModified from the save and update that through the observable
+                    // which will fire onObsChange and save it locally.
+                    if (saved !== undefined && isQueryingModified) {
+                        // Note: Don't need to adjust data because we're just merging dateModified
+                        const invertedMap = fieldTransforms && invertFieldMap(fieldTransforms);
+                        if (invertedMap) {
+                            saved = transformObject(saved, invertedMap, [dateModifiedKey]);
+                        }
                         onChangeRemote(() => {
-                            mergeIntoObservable(obs, saved);
+                            mergeDateModified(obs, saved);
                         });
-                        dateModified = saved[symbolDateModified];
-                        // Replace the dateModifiedKey and remove null/undefined before saving
-                        if (config.fieldTransforms) {
-                            saved = transformObject(saved, config.fieldTransforms, [dateModifiedKey]);
-                        }
-                        saved = replaceKeyInObject(removeNullUndefined(saved), symbolDateModified, dateModifiedKey, 
-                        /*clone*/ false);
-                        toSave = toSave ? mergeIntoObservable(toSave, saved) : saved;
-                    }
-                    if (saved !== undefined || didDelete) {
-                        persistenceLocal.set(table, toSave, [changes[i]], config);
-                        persistenceLocal.updateMetadata(table, { pending, modified: dateModified }, config);
                     }
                 }
+                localState.onSaveRemoteListeners.forEach((cb) => cb());
             });
-        }
+        });
     }
 }
 function onChangeRemote(cb) {
@@ -264,23 +383,33 @@ function onChangeRemote(cb) {
     }
 }
 async function loadLocal(obs, persistOptions, obsState, localState) {
-    var _a;
+    var _a, _b, _c, _d;
     const { local, remote } = persistOptions;
     const localPersistence = persistOptions.persistLocal || observablePersistConfiguration.persistLocal;
     if (local) {
         const { table, config } = parseLocalConfig(local);
+        const isQueryingModified = !!((_b = (_a = persistOptions.remote) === null || _a === void 0 ? void 0 : _a.firebase) === null || _b === void 0 ? void 0 : _b.queryByModified);
         if (!localPersistence) {
             throw new Error('Local persistence is not configured');
         }
         // Ensure there's only one instance of the persistence plugin
         if (!mapPersistences.has(localPersistence)) {
             const persistenceLocal = new localPersistence();
+            const mapValue = { persist: persistenceLocal, initialized: observable(false) };
+            mapPersistences.set(localPersistence, mapValue);
             if (persistenceLocal.initialize) {
-                await ((_a = persistenceLocal.initialize) === null || _a === void 0 ? void 0 : _a.call(persistenceLocal, observablePersistConfiguration.persistLocalOptions));
+                const initializePromise = (_c = persistenceLocal.initialize) === null || _c === void 0 ? void 0 : _c.call(persistenceLocal, observablePersistConfiguration.persistLocalOptions);
+                if (isPromise(initializePromise)) {
+                    await initializePromise;
+                }
             }
-            mapPersistences.set(localPersistence, persistenceLocal);
+            mapValue.initialized.set(true);
+        }
+        const { persist: persistenceLocal, initialized } = mapPersistences.get(localPersistence);
+        localState.persistenceLocal = persistenceLocal;
+        if (!initialized.get()) {
+            await when(initialized);
         }
-        const persistenceLocal = (localState.persistenceLocal = mapPersistences.get(localPersistence));
         // If persistence has an asynchronous load, wait for it
         if (persistenceLocal.loadTable) {
             const promise = persistenceLocal.loadTable(table, config);
@@ -291,36 +420,46 @@ async function loadLocal(obs, persistOptions, obsState, localState) {
         // Get the value from state
         let value = persistenceLocal.getTable(table, config);
         const metadata = persistenceLocal.getMetadata(table, config);
-        if (config.fieldTransforms) {
-            // Get preloaded translated if available
-            let valueLoaded = persistenceLocal.getTableTransformed(table, config);
-            if (valueLoaded) {
-                value = valueLoaded;
-            }
-            else {
-                const inverted = invertMap(config.fieldTransforms);
-                value = transformObject(value, inverted, [dateModifiedKey]);
-            }
-        }
         if (metadata) {
             const pending = metadata.pending;
             localState.pendingChanges = pending;
         }
         // Merge the data from local persistence into the default state
         if (value !== null && value !== undefined) {
-            if (remote) {
-                replaceKeyInObject(value, dateModifiedKey, symbolDateModified, /*clone*/ false);
+            let { adjustData, fieldTransforms } = config;
+            if (fieldTransforms) {
+                let valueLoaded = (_d = persistenceLocal.getTableTransformed) === null || _d === void 0 ? void 0 : _d.call(persistenceLocal, table, config);
+                if (valueLoaded) {
+                    value = valueLoaded;
+                    fieldTransforms = undefined;
+                }
             }
-            if (metadata === null || metadata === void 0 ? void 0 : metadata.modified) {
-                value[symbolDateModified] = metadata.modified;
+            value = adjustLoadData(value, { adjustData, fieldTransforms }, !!remote && isQueryingModified);
+            if (isPromise(value)) {
+                value = await value;
             }
-            batch(() => mergeIntoObservable(obs, value));
+            batch(() => {
+                // isMergingLocalData prevents saving remotely when two different persistences
+                // are set on the same observable
+                isMergingLocalData = true;
+                // We want to merge the local data on top of any initial state the object is created with
+                mergeIntoObservable(obs, value);
+                if (metadata === null || metadata === void 0 ? void 0 : metadata.modified) {
+                    obs.peek()[symbolDateModified] = metadata.modified;
+                }
+            }, () => {
+                isMergingLocalData = false;
+            });
         }
         obsState.peek().clearLocal = () => persistenceLocal.deleteTable(table, config);
     }
     obsState.isLoadedLocal.set(true);
 }
 function persistObservable(obs, persistOptions) {
+    const { remote, local } = persistOptions;
+    const remotePersistence = persistOptions.persistRemote || (observablePersistConfiguration === null || observablePersistConfiguration === void 0 ? void 0 : observablePersistConfiguration.persistRemote);
+    const onSaveRemoteListeners = [];
+    const localState = { onSaveRemoteListeners };
     const obsState = observable({
         isLoadedLocal: false,
         isLoadedRemote: false,
@@ -328,10 +467,8 @@ function persistObservable(obs, persistOptions) {
         isEnabledRemote: true,
         clearLocal: undefined,
         sync: () => Promise.resolve(),
+        getPendingChanges: () => localState.pendingChanges,
     });
-    const { remote, local } = persistOptions;
-    const remotePersistence = persistOptions.persistRemote || (observablePersistConfiguration === null || observablePersistConfiguration === void 0 ? void 0 : observablePersistConfiguration.persistRemote);
-    const localState = {};
     if (local) {
         loadLocal(obs, persistOptions, obsState, localState);
     }
@@ -341,25 +478,66 @@ function persistObservable(obs, persistOptions) {
         }
         // Ensure there's only one instance of the persistence plugin
         if (!mapPersistences.has(remotePersistence)) {
-            mapPersistences.set(remotePersistence, new remotePersistence());
+            mapPersistences.set(remotePersistence, { persist: new remotePersistence() });
         }
-        localState.persistenceRemote = mapPersistences.get(remotePersistence);
+        localState.persistenceRemote = mapPersistences.get(remotePersistence).persist;
         let isSynced = false;
         const sync = async () => {
+            var _a;
             if (!isSynced) {
                 isSynced = true;
-                localState.persistenceRemote.listen(obs, persistOptions, () => {
-                    obsState.isLoadedRemote.set(true);
-                }, onChangeRemote);
-                await when(obsState.isLoadedRemote);
+                const onSaveRemote = (_a = persistOptions.remote) === null || _a === void 0 ? void 0 : _a.onSaveRemote;
+                if (onSaveRemote) {
+                    onSaveRemoteListeners.push(onSaveRemote);
+                }
+                localState.persistenceRemote.listen({
+                    state: obsState,
+                    obs,
+                    options: persistOptions,
+                    onLoad: () => {
+                        obsState.isLoadedRemote.set(true);
+                    },
+                    onChange: async ({ value, path, mode }) => {
+                        if (value !== undefined) {
+                            value = adjustLoadData(value, remote, true);
+                            if (isPromise(value)) {
+                                value = await value;
+                            }
+                            const pending = localState.pendingChanges;
+                            if (pending) {
+                                Object.keys(pending).forEach((key) => {
+                                    const p = key.split('/').filter((p) => p !== '');
+                                    const { v, t } = pending[key];
+                                    const constructed = constructObjectWithPath(p, v, t);
+                                    value = mergeIntoObservable(value, constructed);
+                                });
+                            }
+                            const invertedMap = remote.fieldTransforms && invertFieldMap(remote.fieldTransforms);
+                            if (path.length && invertedMap) {
+                                path = transformPath(path, invertedMap);
+                            }
+                            onChangeRemote(() => {
+                                setInObservableAtPath(obs, path, value, mode);
+                                mergeDateModified(obs, value);
+                            });
+                        }
+                    },
+                });
+                await when(() => obsState.isLoadedRemote.get() || (remote.allowSaveIfError && obsState.remoteError.get()));
                 const pending = localState.pendingChanges;
                 if (pending) {
+                    localState.isApplyingPending = true;
                     Object.keys(pending).forEach((key) => {
                         const path = key.split('/').filter((p) => p !== '');
-                        const { p, v } = pending[key];
+                        const { p, v, t } = pending[key];
                         // TODO getPrevious if any remote persistence layers need it
-                        onObsChange(obs, obsState, localState, persistOptions, obs.peek(), () => undefined, [{ path, valueAtPath: v, prevAtPath: p }]);
+                        onObsChange(obs, obsState, localState, persistOptions, {
+                            value: obs.peek(),
+                            getPrevious: () => undefined,
+                            changes: [{ path, valueAtPath: v, prevAtPath: p, pathTypes: t }],
+                        });
                     });
+                    localState.isApplyingPending = false;
                 }
             }
         };
@@ -385,5 +563,5 @@ function isInRemoteChange() {
     return tracking.inRemoteChange;
 }
 
-export { configureObservablePersistence, getDateModifiedKey, invertMap, isInRemoteChange, mapPersistences, observablePersistConfiguration, persistObservable, persistState, transformObject, transformPath };
+export { configureObservablePersistence, getDateModifiedKey, invertFieldMap, isInRemoteChange, mapPersistences, observablePersistConfiguration, onChangeRemote, persistObservable, persistState, transformObject, transformPath };
 //# sourceMappingURL=persist.mjs.map