@legendapp/state 2.2.0-next.2 → 2.2.0-next.21

package/persist.mjs

@@ -1,4 +1,4 @@
-import { symbolDelete, isString, isArray, isObject, constructObjectWithPath, deconstructObjectWithPath, internal as internal$1, isObservable, observable, isFunction, getNode, when, isPromise, batch, mergeIntoObservable, isEmpty, setAtPath, setInObservableAtPath } from '@legendapp/state';
+import { symbolDelete, isString, isArray, isObject, constructObjectWithPath, deconstructObjectWithPath, isPromise, getNode, observable, when, internal as internal$1, batch, mergeIntoObservable, isEmpty, setAtPath, endBatch, setInObservableAtPath, getNodeValue, isFunction, whenReady } from '@legendapp/state';
 
 const observablePersistConfiguration = {};
 function configureObservablePersistence(options) {
@@ -137,9 +137,21 @@ function observablePersistRemoteFunctionsAdapter({ get, set, }) {
     const ret = {};
     if (get) {
         ret.get = (async (params) => {
-            const value = (await get(params));
-            params.onChange({ value, dateModified: params.dateModified || Date.now() });
-            params.onGet();
+            try {
+                let value = get(params);
+                if (isPromise(value)) {
+                    value = await value;
+                }
+                params.onChange({
+                    value,
+                    dateModified: params.dateModified,
+                    lastSync: params.lastSync,
+                    mode: params.mode,
+                });
+                params.onGet();
+                // eslint-disable-next-line no-empty
+            }
+            catch (_a) { }
         });
     }
     if (set) {
@@ -148,7 +160,22 @@ function observablePersistRemoteFunctionsAdapter({ get, set, }) {
     return ret;
 }
 
-const { getProxy, globalState } = internal$1;
+function removeNullUndefined(val) {
+    if (val) {
+        Object.keys(val).forEach((key) => {
+            const v = val[key];
+            if (v === null || v === undefined) {
+                delete val[key];
+            }
+            else if (isObject(v)) {
+                removeNullUndefined(v);
+            }
+        });
+    }
+    return val;
+}
+
+const { globalState: globalState$1 } = internal$1;
 const mapPersistences = new WeakMap();
 const metadatas = new WeakMap();
 const promisesLocalSaves = new Set();
@@ -163,11 +190,12 @@ function doInOrder(arg1, arg2) {
     return isPromise(arg1) ? arg1.then(arg2) : arg2(arg1);
 }
 function onChangeRemote(cb) {
-    when(() => !globalState.isLoadingRemote$.get(), () => {
+    when(() => !globalState$1.isLoadingRemote$.get(), () => {
+        endBatch(true);
         // Remote changes should only update local state
-        globalState.isLoadingRemote$.set(true);
+        globalState$1.isLoadingRemote$.set(true);
         batch(cb, () => {
-            globalState.isLoadingRemote$.set(false);
+            globalState$1.isLoadingRemote$.set(false);
         });
     });
 }
@@ -214,35 +242,78 @@ async function updateMetadataImmediate(obs, localState, syncState, persistOption
     const { table, config } = parseLocalConfig(local);
     // Save metadata
     const oldMetadata = metadatas.get(obs);
-    const { modified, pending } = newMetadata;
-    const needsUpdate = pending || (modified && (!oldMetadata || modified !== oldMetadata.modified));
+    const { lastSync, pending } = newMetadata;
+    const needsUpdate = pending || (lastSync && (!oldMetadata || lastSync !== oldMetadata.lastSync));
     if (needsUpdate) {
         const metadata = Object.assign({}, oldMetadata, newMetadata);
         metadatas.set(obs, metadata);
         if (persistenceLocal) {
             await persistenceLocal.setMetadata(table, metadata, config);
         }
-        if (modified) {
-            syncState.dateModified.set(modified);
+        if (lastSync) {
+            syncState.assign({
+                lastSync: lastSync,
+                dateModified: lastSync,
+            });
         }
     }
 }
 function updateMetadata(obs, localState, syncState, persistOptions, newMetadata) {
+    var _a;
     if (localState.timeoutSaveMetadata) {
         clearTimeout(localState.timeoutSaveMetadata);
     }
-    localState.timeoutSaveMetadata = setTimeout(() => updateMetadataImmediate(obs, localState, syncState, persistOptions, newMetadata), 30);
+    localState.timeoutSaveMetadata = setTimeout(() => updateMetadataImmediate(obs, localState, syncState, persistOptions, newMetadata), ((_a = persistOptions === null || persistOptions === void 0 ? void 0 : persistOptions.remote) === null || _a === void 0 ? void 0 : _a.metadataTimeout) || 0);
 }
 let _queuedChanges = [];
+let _queuedRemoteChanges = [];
+let timeoutSaveRemote = undefined;
+function mergeChanges(changes) {
+    const changesByPath = new Map();
+    const changesOut = [];
+    // TODO: This could be even more robust by going deeper into paths like the firebase plugin's _updatePendingSave
+    for (let i = 0; i < changes.length; i++) {
+        const change = changes[i];
+        const pathStr = change.path.join('/');
+        const existing = changesByPath.get(pathStr);
+        if (existing) {
+            existing.valueAtPath = change.valueAtPath;
+        }
+        else {
+            changesByPath.set(pathStr, change);
+            changesOut.push(change);
+        }
+    }
+    return changesOut;
+}
+function mergeQueuedChanges(allChanges) {
+    const changesByObs = new Map();
+    const out = [];
+    for (let i = 0; i < allChanges.length; i++) {
+        const value = allChanges[i];
+        const { obs, changes } = value;
+        const existing = changesByObs.get(obs);
+        const newChanges = existing ? [...existing, ...changes] : changes;
+        const merged = mergeChanges(newChanges);
+        changesByObs.set(obs, merged);
+        if (!existing) {
+            value.changes = merged;
+            out.push(value);
+        }
+    }
+    return out;
+}
 async function processQueuedChanges() {
+    var _a;
     // Get a local copy of the queued changes and clear the global queue
-    const queuedChanges = _queuedChanges;
+    const queuedChanges = mergeQueuedChanges(_queuedChanges);
     _queuedChanges = [];
+    _queuedRemoteChanges.push(...queuedChanges.filter((c) => !c.inRemoteChange));
     // Note: Summary of the order of operations these functions:
     // 1. Prepare all changes for saving. This may involve waiting for promises if the user has asynchronous transform.
     // We need to prepare all of the changes in the queue before saving so that the saves happen in the correct order,
     // since some may take longer to transformSaveData than others.
-    const changes = await Promise.all(queuedChanges.map(prepChange));
+    const preppedChangesLocal = await Promise.all(queuedChanges.map(prepChangeLocal));
     // 2. Save pending to the metadata table first. If this is the only operation that succeeds, it would try to save
     // the current value again on next load, which isn't too bad.
     // 3. Save local changes to storage. If they never make it to remote, then on the next load they will be pending
@@ -250,25 +321,43 @@ async function processQueuedChanges() {
     // 4. Wait for remote load or error if allowed
     // 5. Save to remote
     // 6. On successful save, merge changes (if any) back into observable
-    // 7. Lastly, update metadata to clear pending and update dateModified. Doing this earlier could potentially cause
+    // 7. Lastly, update metadata to clear pending and update lastSync. Doing this earlier could potentially cause
     // sync inconsistences so it's very important that this is last.
-    changes.forEach(doChange);
+    await Promise.all(preppedChangesLocal.map(doChangeLocal));
+    const timeout = (_a = observablePersistConfiguration === null || observablePersistConfiguration === void 0 ? void 0 : observablePersistConfiguration.remoteOptions) === null || _a === void 0 ? void 0 : _a.saveTimeout;
+    if (timeout) {
+        if (timeoutSaveRemote) {
+            clearTimeout(timeoutSaveRemote);
+        }
+        timeoutSaveRemote = setTimeout(processQueuedRemoteChanges, timeout);
+    }
+    else {
+        processQueuedRemoteChanges();
+    }
 }
-async function prepChange(queuedChange) {
+async function processQueuedRemoteChanges() {
+    const queuedRemoteChanges = mergeQueuedChanges(_queuedRemoteChanges);
+    _queuedRemoteChanges = [];
+    const preppedChangesRemote = await Promise.all(queuedRemoteChanges.map(prepChangeRemote));
+    preppedChangesRemote.forEach(doChangeRemote);
+}
+async function prepChangeLocal(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 && syncState.isEnabledLocal.peek();
-    const saveRemote = !inRemoteChange && (persistenceRemote === null || persistenceRemote === void 0 ? void 0 : persistenceRemote.set) && !(configRemote === null || configRemote === void 0 ? void 0 : configRemote.readonly) && syncState.isEnabledRemote.peek();
+    const saveRemote = !!(!inRemoteChange &&
+        (persistenceRemote === null || persistenceRemote === void 0 ? void 0 : persistenceRemote.set) &&
+        !(configRemote === null || configRemote === void 0 ? void 0 : configRemote.readonly) &&
+        syncState.isEnabledRemote.peek());
     if (saveLocal || saveRemote) {
         if (saveLocal && !syncState.isLoadedLocal.peek()) {
             console.error('[legend-state] WARNING: An observable was changed before being loaded from persistence', local);
-            return;
+            return undefined;
         }
         const changesLocal = [];
-        const changesRemote = [];
         const changesPaths = new Set();
         let promisesTransform = [];
         // Reverse order
@@ -307,6 +396,52 @@ async function prepChange(queuedChange) {
                         }
                     }));
                 }
+            }
+        }
+        // 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, saveRemote };
+    }
+}
+async function prepChangeRemote(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 && syncState.isEnabledLocal.peek();
+    const saveRemote = !inRemoteChange && (persistenceRemote === null || persistenceRemote === void 0 ? void 0 : persistenceRemote.set) && !(configRemote === null || configRemote === void 0 ? void 0 : configRemote.readonly) && syncState.isEnabledRemote.peek();
+    if (saveLocal || saveRemote) {
+        if (saveLocal && !syncState.isLoadedLocal.peek()) {
+            console.error('[legend-state] WARNING: An observable was changed before being loaded from persistence', local);
+            return undefined;
+        }
+        const changesRemote = [];
+        const changesPaths = new Set();
+        let promisesTransform = [];
+        // Reverse order
+        for (let i = changes.length - 1; i >= 0; i--) {
+            const { path } = changes[i];
+            let found = false;
+            // Optimization to only save the latest update at each path. We might have multiple changes at the same path
+            // and we only need the latest value, so it starts from the end of the array, skipping any earlier changes
+            // already processed. If a later change modifies a parent of an earlier change (which happens on delete()
+            // it should be ignored as it's superseded by the parent modification.
+            if (changesPaths.size > 0) {
+                for (let u = 0; u < path.length; u++) {
+                    if (changesPaths.has((u === path.length - 1 ? path : path.slice(0, u + 1)).join('/'))) {
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found) {
+                const pathStr = path.join('/');
+                changesPaths.add(pathStr);
+                const { prevAtPath, valueAtPath, pathTypes } = changes[i];
                 if (saveRemote) {
                     const promiseTransformRemote = transformOutData(valueAtPath, path, pathTypes, configRemote || {});
                     promisesTransform.push(doInOrder(promiseTransformRemote, ({ path: pathTransformed, value: valueTransformed }) => {
@@ -364,21 +499,20 @@ async function prepChange(queuedChange) {
         if (promisesTransform.length > 0) {
             await Promise.all(promisesTransform);
         }
-        return { queuedChange, changesLocal, changesRemote };
+        return { queuedChange, changesRemote };
     }
 }
-async function doChange(changeInfo) {
-    var _a, _b, _c, _d;
+async function doChangeLocal(changeInfo) {
     if (!changeInfo)
         return;
-    const { queuedChange, changesLocal, changesRemote } = changeInfo;
+    const { queuedChange, changesLocal, saveRemote } = changeInfo;
     const { obs, syncState, localState, persistOptions } = queuedChange;
-    const { persistenceLocal, persistenceRemote } = localState;
+    const { persistenceLocal } = localState;
     const local = persistOptions.local;
     const { table, config: configLocal } = parseLocalConfig(local);
     const configRemote = persistOptions.remote;
     const shouldSaveMetadata = local && (configRemote === null || configRemote === void 0 ? void 0 : configRemote.offlineBehavior) === 'retry';
-    if (changesRemote.length > 0 && shouldSaveMetadata) {
+    if (saveRemote && shouldSaveMetadata) {
         // First save pending changes before saving local or remote
         await updateMetadataImmediate(obs, localState, syncState, persistOptions, {
             pending: localState.pendingChanges,
@@ -398,11 +532,24 @@ async function doChange(changeInfo) {
             await promiseSet;
         }
     }
+}
+async function doChangeRemote(changeInfo) {
+    var _a, _b, _c, _d;
+    if (!changeInfo)
+        return;
+    const { queuedChange, changesRemote } = changeInfo;
+    const { obs, syncState, localState, persistOptions } = queuedChange;
+    const { persistenceLocal, persistenceRemote } = localState;
+    const local = persistOptions.local;
+    const { table, config: configLocal } = parseLocalConfig(local);
+    const configRemote = persistOptions.remote;
+    const shouldSaveMetadata = local && (configRemote === null || configRemote === void 0 ? void 0 : configRemote.offlineBehavior) === 'retry';
     if (changesRemote.length > 0) {
         // Wait for remote to be ready before saving
         await when(() => syncState.isLoaded.get() || ((configRemote === null || configRemote === void 0 ? void 0 : configRemote.allowSetIfError) && syncState.error.get()));
         const value = obs.peek();
         (_a = configRemote === null || configRemote === void 0 ? void 0 : configRemote.onBeforeSet) === null || _a === void 0 ? void 0 : _a.call(configRemote);
+        localState.numSavesOutstanding = (localState.numSavesOutstanding || 0) + 1;
         const saved = await ((_b = persistenceRemote.set({
             obs,
             syncState: syncState,
@@ -410,17 +557,18 @@ async function doChange(changeInfo) {
             changes: changesRemote,
             value,
         })) === null || _b === void 0 ? void 0 : _b.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); }));
+        localState.numSavesOutstanding--;
         // 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 (saved) {
             const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
-            const { changes, dateModified } = saved;
+            const { changes, lastSync } = saved;
             if (pathStrs.length > 0) {
                 if (local) {
                     const metadata = {};
                     const pending = (_c = persistenceLocal.getMetadata(table, configLocal)) === null || _c === void 0 ? void 0 : _c.pending;
-                    let transformedChanges = [];
+                    let transformedChanges = undefined;
                     for (let i = 0; i < pathStrs.length; i++) {
                         const pathStr = pathStrs[i];
                         // Clear pending for this path
@@ -430,22 +578,34 @@ async function doChange(changeInfo) {
                             metadata.pending = pending;
                         }
                     }
-                    if (dateModified) {
-                        metadata.modified = dateModified;
+                    if (lastSync) {
+                        metadata.lastSync = lastSync;
                     }
                     // Remote can optionally have data that needs to be merged back into the observable,
                     // for example Firebase may update dateModified with the server timestamp
                     if (changes && !isEmpty(changes)) {
-                        transformedChanges.push(transformLoadData(changes, persistOptions.remote, false));
+                        transformedChanges = transformLoadData(changes, persistOptions.remote, false);
                     }
-                    if (transformedChanges.length > 0) {
-                        if (transformedChanges.some((change) => isPromise(change))) {
-                            transformedChanges = await Promise.all(transformedChanges);
+                    if (localState.numSavesOutstanding > 0) {
+                        if (transformedChanges) {
+                            if (!localState.pendingSaveResults) {
+                                localState.pendingSaveResults = [];
+                            }
+                            localState.pendingSaveResults.push(transformedChanges);
                         }
-                        onChangeRemote(() => mergeIntoObservable(obs, ...transformedChanges));
                     }
-                    if (shouldSaveMetadata && !isEmpty(metadata)) {
-                        updateMetadata(obs, localState, syncState, persistOptions, metadata);
+                    else {
+                        let allChanges = [...(localState.pendingSaveResults || []), transformedChanges];
+                        if (allChanges.length > 0) {
+                            if (allChanges.some((change) => isPromise(change))) {
+                                allChanges = await Promise.all(allChanges);
+                            }
+                            onChangeRemote(() => mergeIntoObservable(obs, ...allChanges));
+                        }
+                        if (shouldSaveMetadata && !isEmpty(metadata)) {
+                            updateMetadata(obs, localState, syncState, persistOptions, metadata);
+                        }
+                        localState.pendingSaveResults = [];
                     }
                 }
                 (_d = configRemote === null || configRemote === void 0 ? void 0 : configRemote.onSet) === null || _d === void 0 ? void 0 : _d.call(configRemote);
@@ -496,7 +656,7 @@ async function loadLocal(obs, persistOptions, syncState, localState) {
         }
         const { persist: persistenceLocal, initialized } = mapPersistences.get(localPersistence);
         localState.persistenceLocal = persistenceLocal;
-        if (!initialized.get()) {
+        if (!initialized.peek()) {
             await when(initialized);
         }
         // If persistence has an asynchronous load, wait for it
@@ -510,12 +670,21 @@ async function loadLocal(obs, persistOptions, syncState, localState) {
         let value = persistenceLocal.getTable(table, config);
         const metadata = persistenceLocal.getMetadata(table, config);
         if (metadata) {
+            // @ts-expect-error Migration from old version
+            if (!metadata.lastSync && metadata.modified) {
+                // @ts-expect-error Migration from old
+                metadata.lastSync = metadata.modified;
+            }
             metadatas.set(obs, metadata);
             localState.pendingChanges = metadata.pending;
-            syncState.dateModified.set(metadata.modified);
+            // TODOV3 Remove dateModified
+            syncState.assign({
+                dateModified: metadata.lastSync,
+                lastSync: metadata.lastSync,
+            });
         }
         // Merge the data from local persistence into the default state
-        if (value !== null && value !== undefined) {
+        if (value !== undefined) {
             const { transform, fieldTransforms } = config;
             value = transformLoadData(value, { transform, fieldTransforms }, true);
             if (isPromise(value)) {
@@ -526,7 +695,12 @@ async function loadLocal(obs, persistOptions, syncState, localState) {
                 // are set on the same observable
                 internal$1.globalState.isLoadingLocal = true;
                 // We want to merge the local data on top of any initial state the object is created with
-                mergeIntoObservable(obs, value);
+                if (value === null && !obs.peek()) {
+                    obs.set(value);
+                }
+                else {
+                    mergeIntoObservable(obs, value);
+                }
             }, () => {
                 internal$1.globalState.isLoadingLocal = false;
             });
@@ -539,18 +713,11 @@ async function loadLocal(obs, persistOptions, syncState, localState) {
     }
     syncState.isLoadedLocal.set(true);
 }
-function persistObservable(initialOrObservable, persistOptions) {
-    var _a;
-    const obs = (isObservable(initialOrObservable)
-        ? initialOrObservable
-        : observable(isFunction(initialOrObservable) ? initialOrObservable() : initialOrObservable));
+function persistObservable(obs, persistOptions) {
     const node = getNode(obs);
-    if (process.env.NODE_ENV === 'development' && ((_a = obs === null || obs === void 0 ? void 0 : obs.peek()) === null || _a === void 0 ? void 0 : _a._state)) {
-        console.warn('[legend-state] WARNING: persistObservable creates a property named "_state" but your observable already has "state" in it');
-    }
     // Merge remote persist options with clobal options
     if (persistOptions.remote) {
-        persistOptions.remote = Object.assign({}, observablePersistConfiguration.remoteOptions, persistOptions.remote);
+        persistOptions.remote = Object.assign({}, observablePersistConfiguration.remoteOptions, removeNullUndefined(persistOptions.remote));
     }
     let { remote } = persistOptions;
     const { local } = persistOptions;
@@ -562,6 +729,7 @@ function persistObservable(initialOrObservable, persistOptions) {
         isLoaded: false,
         isEnabledLocal: true,
         isEnabledRemote: true,
+        refreshNum: 0,
         clearLocal: undefined,
         sync: () => Promise.resolve(),
         getPendingChanges: () => localState.pendingChanges,
@@ -592,73 +760,93 @@ function persistObservable(initialOrObservable, persistOptions) {
             var _a, _b;
             if (!isSynced) {
                 isSynced = true;
-                const dateModified = (_a = metadatas.get(obs)) === null || _a === void 0 ? void 0 : _a.modified;
+                const lastSync = (_a = metadatas.get(obs)) === null || _a === void 0 ? void 0 : _a.lastSync;
+                const pending = localState.pendingChanges;
                 const get = (_b = localState.persistenceRemote.get) === null || _b === void 0 ? void 0 : _b.bind(localState.persistenceRemote);
                 if (get) {
-                    get({
-                        state: syncState,
-                        obs,
-                        options: persistOptions,
-                        dateModified,
-                        onGet: () => {
-                            syncState.isLoaded.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 = transformLoadData(value, remote, true);
-                                if (isPromise(value)) {
-                                    value = await value;
-                                }
-                                const invertedMap = remote.fieldTransforms && invertFieldMap(remote.fieldTransforms);
-                                if (path.length && invertedMap) {
-                                    path = transformPath(path, pathTypes, invertedMap);
-                                }
-                                if (mode === 'dateModified') {
-                                    if (dateModified && !isEmpty(value)) {
+                    const runGet = () => {
+                        get({
+                            state: syncState,
+                            obs,
+                            options: persistOptions,
+                            lastSync,
+                            dateModified: lastSync,
+                            onError: (error) => {
+                                var _a;
+                                (_a = remote.onGetError) === null || _a === void 0 ? void 0 : _a.call(remote, error);
+                            },
+                            onGet: () => {
+                                node.state.assign({
+                                    isLoaded: true,
+                                    error: undefined,
+                                });
+                            },
+                            onChange: async ({ value, path = [], pathTypes = [], mode = 'set', lastSync }) => {
+                                // 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 = transformLoadData(value, remote, true);
+                                    if (isPromise(value)) {
+                                        value = await value;
+                                    }
+                                    const invertedMap = remote.fieldTransforms && invertFieldMap(remote.fieldTransforms);
+                                    if (path.length && invertedMap) {
+                                        path = transformPath(path, pathTypes, invertedMap);
+                                    }
+                                    if (mode === 'lastSync' || mode === 'dateModified') {
+                                        if (lastSync && !isEmpty(value)) {
+                                            onChangeRemote(() => {
+                                                setInObservableAtPath(
+                                                // @ts-expect-error Fix this type
+                                                obs, path, pathTypes, value, 'assign');
+                                            });
+                                        }
+                                    }
+                                    else {
+                                        const pending = localState.pendingChanges;
+                                        if (pending) {
+                                            Object.keys(pending).forEach((key) => {
+                                                const p = key.split('/').filter((p) => p !== '');
+                                                const { v, t } = pending[key];
+                                                if (t.length === 0) {
+                                                    value = v;
+                                                }
+                                                else if (value[p[0]] !== undefined) {
+                                                    value = 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(() => {
-                                            setInObservableAtPath(obs, path, pathTypes, value, 'assign');
+                                            // @ts-expect-error Fix this type
+                                            setInObservableAtPath(obs, path, pathTypes, value, mode);
                                         });
                                     }
                                 }
-                                else {
-                                    const pending = localState.pendingChanges;
-                                    if (pending) {
-                                        Object.keys(pending).forEach((key) => {
-                                            const p = key.split('/').filter((p) => p !== '');
-                                            const { v, t } = pending[key];
-                                            if (value[p[0]] !== undefined) {
-                                                value = 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(() => {
-                                        setInObservableAtPath(obs, path, pathTypes, value, mode);
+                                if (lastSync && local) {
+                                    updateMetadata(obs, localState, syncState, persistOptions, {
+                                        lastSync,
                                     });
                                 }
-                            }
-                            if (dateModified && local) {
-                                updateMetadata(obs, localState, syncState, persistOptions, {
-                                    modified: dateModified,
-                                });
-                            }
-                        },
-                    });
+                            },
+                        });
+                    };
+                    runGet();
                 }
                 else {
-                    syncState.isLoaded.set(true);
+                    node.state.assign({
+                        isLoaded: true,
+                        error: undefined,
+                    });
                 }
                 // Wait for remote to be ready before saving pending
                 await when(() => syncState.isLoaded.get() || (remote.allowSetIfError && syncState.error.get()));
-                const pending = localState.pendingChanges;
                 if (pending && !isEmpty(pending)) {
                     localState.isApplyingPending = true;
                     const keys = Object.keys(pending);
@@ -671,6 +859,7 @@ function persistObservable(initialOrObservable, persistOptions) {
                         changes.push({ path, valueAtPath: v, prevAtPath: p, pathTypes: t });
                     }
                     // Send the changes into onObsChange so that they get persisted remotely
+                    // @ts-expect-error Fix this type
                     onObsChange(obs, syncState, localState, persistOptions, {
                         value: obs.peek(),
                         // TODO getPrevious if any remote persistence layers need it
@@ -706,44 +895,122 @@ function persistObservable(initialOrObservable, persistOptions) {
         }
         obs.onChange(onObsChange.bind(this, obs, syncState, localState, persistOptions));
     });
-    return obs;
+    return syncState;
 }
-globalState.activateNode = function activateNodePersist(node, newValue, setter, subscriber, cacheOptions, lastSync) {
-    let onChange = undefined;
-    const pluginRemote = {
-        get: async (params) => {
-            onChange = params.onChange;
-            if (isPromise(newValue)) {
-                newValue = await newValue;
+
+const { getProxy, globalState, runWithRetry, symbolActivated } = internal$1;
+function persistActivateNode() {
+    globalState.activateNode = function activateNodePersist(node, refresh, wasPromise, newValue) {
+        if (node.activationState) {
+            const { get, initial, onSet, subscribe, cache, retry, offlineBehavior } = node.activationState;
+            let onChange = undefined;
+            const pluginRemote = {};
+            if (get) {
+                pluginRemote.get = (params) => {
+                    onChange = params.onChange;
+                    const updateLastSync = (lastSync) => (params.lastSync = lastSync);
+                    const setMode = (mode) => (params.mode = mode);
+                    const nodeValue = getNodeValue(node);
+                    const value = runWithRetry(node, { attemptNum: 0 }, () => {
+                        return get({
+                            value: isFunction(nodeValue) || (nodeValue === null || nodeValue === void 0 ? void 0 : nodeValue[symbolActivated]) ? undefined : nodeValue,
+                            lastSync: params.lastSync,
+                            updateLastSync,
+                            setMode,
+                        });
+                    });
+                    return value;
+                };
+            }
+            if (onSet) {
+                // TODO: Work out these types better
+                pluginRemote.set = async (params) => {
+                    var _a;
+                    if ((_a = node.state) === null || _a === void 0 ? void 0 : _a.isLoaded.get()) {
+                        return runWithRetry(node, { attemptNum: 0 }, async () => {
+                            let changes = {};
+                            let maxModified = 0;
+                            let didError = false;
+                            if (!node.state.isLoaded.peek()) {
+                                await whenReady(node.state.isLoaded);
+                            }
+                            await onSet({
+                                ...params,
+                                node,
+                                update: (params) => {
+                                    const { value, lastSync } = params;
+                                    maxModified = Math.max(lastSync || 0, maxModified);
+                                    changes = mergeIntoObservable(changes, value);
+                                },
+                                onError: () => {
+                                    // TODO Is this necessary?
+                                    didError = true;
+                                    throw new Error();
+                                },
+                                refresh,
+                                fromSubscribe: false,
+                            });
+                            if (!didError) {
+                                return { changes, lastSync: maxModified || undefined };
+                            }
+                        });
+                    }
+                };
+            }
+            if (subscribe) {
+                subscribe({
+                    node,
+                    update: (params) => {
+                        if (!onChange) {
+                            // TODO: Make this message better
+                            console.log('[legend-state] Cannot update immediately before the first return');
+                        }
+                        else {
+                            onChange(params);
+                        }
+                    },
+                    refresh,
+                });
+            }
+            persistObservable(getProxy(node), {
+                pluginRemote,
+                ...(cache || {}),
+                remote: {
+                    retry: retry,
+                    offlineBehavior,
+                },
+            });
+            const nodeVal = getNodeValue(node);
+            if (nodeVal !== undefined) {
+                newValue = nodeVal;
             }
-            if (lastSync.value) {
-                params.dateModified = lastSync.value;
+            else if (newValue === undefined) {
+                newValue = initial;
             }
-            return newValue;
-        },
+            return { update: onChange, value: newValue };
+        }
+        else {
+            let onChange = undefined;
+            const pluginRemote = {
+                get: async (params) => {
+                    onChange = params.onChange;
+                    if (isPromise(newValue)) {
+                        try {
+                            newValue = await newValue;
+                            // eslint-disable-next-line no-empty
+                        }
+                        catch (_a) { }
+                    }
+                    return newValue;
+                },
+            };
+            persistObservable(getProxy(node), {
+                pluginRemote,
+            });
+            return { update: onChange, value: newValue };
+        }
     };
-    if (setter) {
-        pluginRemote.set = setter;
-    }
-    if (subscriber) {
-        subscriber({
-            update: (params) => {
-                if (!onChange) {
-                    // TODO: Make this message better
-                    console.log('[legend-state] Cannot update immediately before the first return');
-                }
-                else {
-                    onChange(params);
-                }
-            },
-        });
-    }
-    persistObservable(getProxy(node), {
-        pluginRemote,
-        ...(cacheOptions || {}),
-    });
-    return { update: onChange };
-};
+}
 
 function isInRemoteChange() {
     return internal$1.globalState.isLoadingRemote$.get();
@@ -751,6 +1018,7 @@ function isInRemoteChange() {
 const internal = {
     observablePersistConfiguration,
 };
+persistActivateNode();
 
 export { configureObservablePersistence, internal, invertFieldMap, isInRemoteChange, mapPersistences, persistObservable, transformObject, transformPath };
 //# sourceMappingURL=persist.mjs.map