@legendapp/state 2.2.0-next.74 → 2.2.0-next.76

package/persist.js

@@ -136,19 +136,14 @@ if (process.env.NODE_ENV === 'development') {
     };
 }
 
-function removeNullUndefined(val) {
-    if (val) {
-        Object.keys(val).forEach((key) => {
-            const v = val[key];
-            if (v === null || v === undefined) {
-                delete val[key];
-            }
-            else if (state.isObject(v)) {
-                removeNullUndefined(v);
-            }
-        });
-    }
-    return val;
+function removeNullUndefined(a, recursive) {
+    const out = {};
+    Object.keys(a).forEach((key) => {
+        if (a[key] !== null && a[key] !== undefined) {
+            out[key] = recursive && state.isObject(a[key]) ? removeNullUndefined(a[key]) : a[key];
+        }
+    });
+    return out;
 }
 
 function observablePersistRemoteFunctionsAdapter({ get, set, }) {
@@ -1279,8 +1274,7 @@ async function doChangeLocal(changeInfo) {
     const { pluginPersist } = localState;
     const persist = syncOptions.persist;
     const { table, config: configLocal } = parseLocalConfig(persist);
-    const configRemote = syncOptions;
-    const shouldSaveMetadata = persist && (configRemote === null || configRemote === void 0 ? void 0 : configRemote.offlineBehavior) === 'retry';
+    const shouldSaveMetadata = persist === null || persist === void 0 ? void 0 : persist.retrySync;
     if (saveRemote && shouldSaveMetadata) {
         // First save pending changes before saving local or remote
         await updateMetadataImmediate(obs, localState, syncState, syncOptions, {
@@ -1311,8 +1305,8 @@ async function doChangeRemote(changeInfo) {
     const { pluginPersist, pluginSync } = localState;
     const persist = syncOptions.persist;
     const { table, config: configLocal } = parseLocalConfig(persist);
-    const { offlineBehavior, allowSetIfGetError, onBeforeSet, onSetError, waitForSet, onAfterSet } = syncOptions || {};
-    const shouldSaveMetadata = persist && offlineBehavior === 'retry';
+    const { allowSetIfGetError, onBeforeSet, onSetError, waitForSet, onAfterSet } = syncOptions || {};
+    const shouldSaveMetadata = persist === null || persist === void 0 ? void 0 : persist.retrySync;
     if (changesRemote.length > 0) {
         // Wait for remote to be ready before saving
         await state.when(() => syncState.isLoaded.get() || (allowSetIfGetError && syncState.error.get()));
@@ -1351,11 +1345,11 @@ async function doChangeRemote(changeInfo) {
             const pathStrs = Array.from(new Set(changesRemote.map((change) => change.pathStr)));
             const { changes, lastSync } = saved;
             if (pathStrs.length > 0) {
+                let transformedChanges = undefined;
+                const metadata = {};
                 if (persist) {
-                    const metadata = {};
                     const pendingMetadata = (_b = pluginPersist.getMetadata(table, configLocal)) === null || _b === void 0 ? void 0 : _b.pending;
                     const pending = localState.pendingChanges;
-                    let transformedChanges = undefined;
                     for (let i = 0; i < pathStrs.length; i++) {
                         const pathStr = pathStrs[i];
                         // Clear pending for this path
@@ -1374,32 +1368,34 @@ async function doChangeRemote(changeInfo) {
                     if (lastSync) {
                         metadata.lastSync = lastSync;
                     }
-                    // Remote can optionally have data that needs to be merged back into the observable,
-                    // for example Firebase may update dateModified with the server timestamp
-                    if (changes && !state.isEmpty(changes)) {
-                        transformedChanges = transformLoadData(changes, syncOptions, false);
-                    }
-                    if (localState.numSavesOutstanding > 0) {
-                        if (transformedChanges) {
-                            if (!localState.pendingSaveResults) {
-                                localState.pendingSaveResults = [];
-                            }
-                            localState.pendingSaveResults.push(transformedChanges);
+                }
+                // Remote can optionally have data that needs to be merged back into the observable,
+                // for example Firebase may update dateModified with the server timestamp
+                if (changes && !state.isEmpty(changes)) {
+                    transformedChanges = transformLoadData(changes, syncOptions, false);
+                }
+                if (localState.numSavesOutstanding > 0) {
+                    if (transformedChanges) {
+                        if (!localState.pendingSaveResults) {
+                            localState.pendingSaveResults = [];
                         }
+                        localState.pendingSaveResults.push(transformedChanges);
                     }
-                    else {
-                        let allChanges = [...(localState.pendingSaveResults || []), transformedChanges].filter((v) => v !== undefined);
-                        if (allChanges.length > 0) {
-                            if (allChanges.some((change) => state.isPromise(change))) {
-                                allChanges = await Promise.all(allChanges);
-                            }
-                            onChangeRemote(() => state.mergeIntoObservable(obs, ...allChanges));
+                }
+                else {
+                    let allChanges = [...(localState.pendingSaveResults || []), transformedChanges].filter((v) => v !== undefined);
+                    if (allChanges.length > 0) {
+                        if (allChanges.some((change) => state.isPromise(change))) {
+                            allChanges = await Promise.all(allChanges);
                         }
+                        onChangeRemote(() => state.mergeIntoObservable(obs, ...allChanges));
+                    }
+                    if (persist) {
                         if (shouldSaveMetadata && !state.isEmpty(metadata)) {
                             updateMetadata(obs, localState, syncState, syncOptions, metadata);
                         }
-                        localState.pendingSaveResults = [];
                     }
+                    localState.pendingSaveResults = [];
                 }
                 onAfterSet === null || onAfterSet === void 0 ? void 0 : onAfterSet();
             }
@@ -1535,6 +1531,77 @@ function syncObservable(obs$, syncOptionsOrSynced) {
             const get = (_b = localState.pluginSync.get) === null || _b === void 0 ? void 0 : _b.bind(localState.pluginSync);
             if (get) {
                 const runGet = () => {
+                    const onChange = async ({ value, mode, lastSync }) => {
+                        mode = mode || syncOptions.mode || 'set';
+                        if (value !== undefined) {
+                            value = transformLoadData(value, syncOptions, true);
+                            if (state.isPromise(value)) {
+                                value = await value;
+                            }
+                            const pending = localState.pendingChanges;
+                            const currentValue = obs$.peek();
+                            if (pending) {
+                                let didChangeMetadata = false;
+                                Object.keys(pending).forEach((key) => {
+                                    const p = key.split('/').filter((p) => p !== '');
+                                    const { v, t } = pending[key];
+                                    if (t.length === 0 || !value) {
+                                        if (state.isObject(value) && state.isObject(v)) {
+                                            Object.assign(value, v);
+                                        }
+                                        else {
+                                            value = v;
+                                        }
+                                    }
+                                    else if (value[p[0]] !== undefined) {
+                                        const curValue = getValueAtPath(currentValue, p);
+                                        const newValue = getValueAtPath(value, p);
+                                        if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
+                                            delete pending[key];
+                                            didChangeMetadata = true;
+                                        }
+                                        else {
+                                            value = state.setAtPath(value, p, t, v, 'merge', obs$.peek(), (path, value) => {
+                                                delete pending[key];
+                                                pending[path.join('/')] = {
+                                                    p: null,
+                                                    v: value,
+                                                    t: t.slice(0, path.length),
+                                                };
+                                            });
+                                        }
+                                    }
+                                });
+                                if (didChangeMetadata) {
+                                    updateMetadata(obs$, localState, syncState, syncOptions, {
+                                        pending,
+                                    });
+                                }
+                            }
+                            onChangeRemote(() => {
+                                if (mode === 'assign' && state.isObject(value)) {
+                                    obs$.assign(value);
+                                }
+                                else if (mode === 'append' && state.isArray(value)) {
+                                    obs$.push(...value);
+                                }
+                                else if (mode === 'prepend' && state.isArray(value)) {
+                                    obs$.splice(0, 0, ...value);
+                                }
+                                else if (mode === 'merge') {
+                                    state.mergeIntoObservable(obs$, value);
+                                }
+                                else {
+                                    obs$.set(value);
+                                }
+                            });
+                        }
+                        if (lastSync && syncOptions.persist) {
+                            updateMetadata(obs$, localState, syncState, syncOptions, {
+                                lastSync,
+                            });
+                        }
+                    };
                     get({
                         state: syncState,
                         obs: obs$,
@@ -1546,82 +1613,23 @@ function syncObservable(obs$, syncOptionsOrSynced) {
                             (_a = syncOptions.onGetError) === null || _a === void 0 ? void 0 : _a.call(syncOptions, error);
                         },
                         onGet: () => {
+                            const isFirstLoad = !node.state.isLoaded.peek();
                             node.state.assign({
                                 isLoaded: true,
                                 error: undefined,
                             });
-                        },
-                        onChange: async ({ value, mode, lastSync }) => {
-                            mode = mode || syncOptions.mode || 'set';
-                            if (value !== undefined) {
-                                value = transformLoadData(value, syncOptions, true);
-                                if (state.isPromise(value)) {
-                                    value = await value;
-                                }
-                                const pending = localState.pendingChanges;
-                                const currentValue = obs$.peek();
-                                if (pending) {
-                                    let didChangeMetadata = false;
-                                    Object.keys(pending).forEach((key) => {
-                                        const p = key.split('/').filter((p) => p !== '');
-                                        const { v, t } = pending[key];
-                                        if (t.length === 0 || !value) {
-                                            if (state.isObject(value) && state.isObject(v)) {
-                                                Object.assign(value, v);
-                                            }
-                                            else {
-                                                value = v;
-                                            }
-                                        }
-                                        else if (value[p[0]] !== undefined) {
-                                            const curValue = getValueAtPath(currentValue, p);
-                                            const newValue = getValueAtPath(value, p);
-                                            if (JSON.stringify(curValue) === JSON.stringify(newValue)) {
-                                                delete pending[key];
-                                                didChangeMetadata = true;
-                                            }
-                                            else {
-                                                value = state.setAtPath(value, p, t, v, 'merge', obs$.peek(), (path, value) => {
-                                                    delete pending[key];
-                                                    pending[path.join('/')] = {
-                                                        p: null,
-                                                        v: value,
-                                                        t: t.slice(0, path.length),
-                                                    };
-                                                });
-                                            }
-                                        }
-                                    });
-                                    if (didChangeMetadata) {
-                                        updateMetadata(obs$, localState, syncState, syncOptions, {
-                                            pending,
-                                        });
-                                    }
-                                }
-                                onChangeRemote(() => {
-                                    if (mode === 'assign' && state.isObject(value)) {
-                                        obs$.assign(value);
-                                    }
-                                    else if (mode === 'append' && state.isArray(value)) {
-                                        obs$.push(...value);
-                                    }
-                                    else if (mode === 'prepend' && state.isArray(value)) {
-                                        obs$.splice(0, 0, ...value);
-                                    }
-                                    else if (mode === 'merge') {
-                                        state.mergeIntoObservable(obs$, value);
-                                    }
-                                    else {
-                                        obs$.set(value);
-                                    }
-                                });
-                            }
-                            if (lastSync && syncOptions.persist) {
-                                updateMetadata(obs$, localState, syncState, syncOptions, {
-                                    lastSync,
+                            if (isFirstLoad && syncOptions.subscribe) {
+                                syncOptions.subscribe({
+                                    node,
+                                    update: (params) => {
+                                        params.mode || (params.mode = syncOptions.mode || 'merge');
+                                        onChange(params);
+                                    },
+                                    refresh: sync,
                                 });
                             }
                         },
+                        onChange,
                     });
                 };
                 runGet();
@@ -1691,7 +1699,7 @@ function enableActivateSyncedNode() {
         const obs$ = getProxy(node);
         if (node.activationState) {
             // If it is a Synced
-            const { get, initial, set, subscribe } = node.activationState;
+            const { get, initial, set } = node.activationState;
             let onChange = undefined;
             const pluginRemote = {};
             let promiseReturn = undefined;
@@ -1703,16 +1711,18 @@ function enableActivateSyncedNode() {
                 pluginRemote.get = (params) => {
                     onChange = params.onChange;
                     const updateLastSync = (lastSync) => (params.lastSync = lastSync);
-                    const setMode = (mode) => (params.mode = mode);
                     const existingValue = getNodeValue(node);
                     const value = runWithRetry(node, { attemptNum: 0 }, () => {
-                        return get({
+                        const paramsToGet = {
                             value: state.isFunction(existingValue) || (existingValue === null || existingValue === void 0 ? void 0 : existingValue[symbolLinked$1]) ? undefined : existingValue,
                             lastSync: params.lastSync,
                             updateLastSync,
-                            setMode,
+                            mode: params.mode,
                             refresh,
-                        });
+                        };
+                        const ret = get(paramsToGet);
+                        params.mode = paramsToGet.mode;
+                        return ret;
                     });
                     promiseReturn = value;
                     return value;
@@ -1764,23 +1774,6 @@ function enableActivateSyncedNode() {
             setNodeValue(node, promiseReturn ? undefined : newValue);
             // @ts-expect-error TODO fix these types
             syncState = syncObservable(obs$, { ...node.activationState, ...pluginRemote });
-            if (subscribe) {
-                state.when(promiseReturn || true, () => {
-                    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,
-                    });
-                });
-            }
             return { update: onChange, value: newValue };
         }
         else {