@legendapp/state 2.2.0-next.19 → 2.2.0-next.20

package/index.d.ts

@@ -3,21 +3,21 @@ export { batch, beginBatch, endBatch } from './src/batching';
 export { computed } from './src/computed';
 export { configureLegendState } from './src/config';
 export { event } from './src/event';
-export { computeSelector, constructObjectWithPath, deconstructObjectWithPath, getObservableIndex, isObservableValueReady, lockObservable, mergeIntoObservable, opaqueObject, setAtPath, setInObservableAtPath, setSilently, } from './src/helpers';
 export { isObservable } from './src/globals';
+export { computeSelector, constructObjectWithPath, deconstructObjectWithPath, getObservableIndex, isObservableValueReady, lockObservable, mergeIntoObservable, opaqueObject, setAtPath, setInObservableAtPath, setSilently, } from './src/helpers';
 export { hasOwnProperty, isArray, isBoolean, isEmpty, isFunction, isObject, isPrimitive, isPromise, isString, isSymbol, } from './src/is';
 export { observable, observablePrimitive, syncState } from './src/observable';
 export * from './src/observableInterfaces';
-export * from './src/persistTypes';
+export * from './src/observableTypes';
 export { observe } from './src/observe';
+export * from './src/persistTypes';
 export { proxy } from './src/proxy';
 export { trackSelector } from './src/trackSelector';
 export { when, whenReady } from './src/when';
-export * from './src/observableTypes';
 import { get, getProxy, peek, set } from './src/ObservableObject';
 import { ensureNodeValue, findIDKey, getNode, setNodeValue } from './src/globals';
 import { setAtPath } from './src/helpers';
-import { setupRetry } from './src/retry';
+import { runWithRetry } from './src/retry';
 export declare const internal: {
     ensureNodeValue: typeof ensureNodeValue;
     findIDKey: typeof findIDKey;
@@ -38,10 +38,10 @@ export declare const internal: {
     observableFns: Map<string, (node: import("./src/observableInterfaces").NodeValue, ...args: any[]) => any>;
     optimized: symbol;
     peek: typeof peek;
+    runWithRetry: typeof runWithRetry;
     set: typeof set;
     setAtPath: typeof setAtPath;
     setNodeValue: typeof setNodeValue;
-    setupRetry: typeof setupRetry;
     symbolActivated: symbol;
     symbolDelete: symbol;
 };

package/index.js

@@ -483,6 +483,30 @@ function endBatch(force) {
     }
 }
 
+function createObservable(value, makePrimitive, extractPromise, createObject, createPrimitive) {
+    const valueIsPromise = isPromise(value);
+    const valueIsFunction = isFunction(value);
+    const root = {
+        _: value,
+    };
+    let node = {
+        root,
+        lazy: true,
+    };
+    if (valueIsFunction) {
+        node = Object.assign(cloneFunction(value), node);
+    }
+    const prim = makePrimitive || isActualPrimitive(value);
+    const obs = prim
+        ? new createPrimitive(node)
+        : createObject(node);
+    if (valueIsPromise) {
+        setNodeValue(node, undefined);
+        extractPromise(node, value);
+    }
+    return obs;
+}
+
 function isEvent(obs) {
     var _a;
     return obs && ((_a = obs[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isEvent);
@@ -654,30 +678,6 @@ function setSilently(obs, newValue) {
     return setNodeValue(node, newValue).newValue;
 }
 
-function createObservable(value, makePrimitive, extractPromise, createObject, createPrimitive) {
-    const valueIsPromise = isPromise(value);
-    const valueIsFunction = isFunction(value);
-    const root = {
-        _: value,
-    };
-    let node = {
-        root,
-        lazy: true,
-    };
-    if (valueIsFunction) {
-        node = Object.assign(cloneFunction(value), node);
-    }
-    const prim = makePrimitive || isActualPrimitive(value);
-    const obs = prim
-        ? new createPrimitive(node)
-        : createObject(node);
-    if (valueIsPromise) {
-        setNodeValue(node, undefined);
-        extractPromise(node, value);
-    }
-    return obs;
-}
-
 function onChange(node, callback, options = {}) {
     const { initial, immediate, noArgs } = options;
     const { trackingType } = options;
@@ -868,41 +868,6 @@ function observe(selectorOrRun, reactionOrOptions, options) {
     };
 }
 
-function setupRetry(retryOptions, refresh, attemptNum) {
-    const timeout = {};
-    // let didGiveUp = false;
-    const { backoff, delay = 1000, infinite, times = 3, maxDelay = 30000 } = retryOptions;
-    let handleError;
-    attemptNum.current++;
-    if (infinite || attemptNum.current < times) {
-        const delayTime = Math.min(delay * (backoff === 'constant' ? 1 : 2 ** attemptNum.current), maxDelay);
-        handleError = () => {
-            timeout.current = setTimeout(refresh, delayTime);
-        };
-    }
-    else {
-        handleError = () => {
-            // didGiveUp = true;
-        };
-    }
-    // TODO: Make an easy way to opt into this if
-    // if (typeof window !== 'undefined') {
-    //     window.addEventListener('online', () => {
-    //         if (didGiveUp || timeout) {
-    //             if (timeout) {
-    //                 clearTimeout(timeout.current);
-    //                 timeout.current = undefined;
-    //             }
-    //             // Restart the backoff when coming back online
-    //             attemptNum.current = 0;
-    //             didGiveUp = false;
-    //             refresh();
-    //         }
-    //     });
-    // }
-    return { handleError, timeout };
-}
-
 function _when(predicate, effect, checkReady) {
     // If predicate is a regular Promise skip all the observable stuff
     if (isPromise(predicate)) {
@@ -958,6 +923,59 @@ function whenReady(predicate, effect) {
     return _when(predicate, effect, true);
 }
 
+function calculateRetryDelay(retryOptions, attemptNum) {
+    const { backoff, delay = 1000, infinite, times = 3, maxDelay = 30000 } = retryOptions;
+    if (infinite || attemptNum < times) {
+        const delayTime = Math.min(delay * (backoff === 'constant' ? 1 : 2 ** attemptNum), maxDelay);
+        return delayTime;
+    }
+    return null;
+}
+function createRetryTimout(retryOptions, attemptNum, fn) {
+    const delayTime = calculateRetryDelay(retryOptions, attemptNum);
+    if (delayTime) {
+        return setTimeout(fn, delayTime);
+    }
+}
+function runWithRetry(node, state, fn) {
+    const { retry, waitFor } = node.activationState;
+    let value = undefined;
+    if (waitFor) {
+        value = whenReady(waitFor, () => {
+            node.activationState.waitFor = undefined;
+            return fn();
+        });
+    }
+    else {
+        value = fn();
+    }
+    if (isPromise(value) && retry) {
+        let timeoutRetry;
+        return new Promise((resolve) => {
+            const run = () => {
+                value
+                    .then((val) => {
+                    node.activationState.persistedRetry = false;
+                    resolve(val);
+                })
+                    .catch(() => {
+                    node.activationState.persistedRetry = true;
+                    state.attemptNum++;
+                    if (timeoutRetry) {
+                        clearTimeout(timeoutRetry);
+                    }
+                    timeoutRetry = createRetryTimout(retry, state.attemptNum, () => {
+                        value = fn();
+                        run();
+                    });
+                });
+            };
+            run();
+        });
+    }
+    return value;
+}
+
 const noop = () => { };
 const ArrayModifiers = new Set([
     'copyWithin',
@@ -1610,7 +1628,7 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
     }
     endBatch();
 }
-function extractPromise(node, value, setter, handleError) {
+function extractPromise(node, value, setter) {
     if (!node.state) {
         node.state = createObservable({
             isLoaded: false,
@@ -1626,9 +1644,6 @@ function extractPromise(node, value, setter, handleError) {
     })
         .catch((error) => {
         node.state.error.set(error);
-        if (handleError) {
-            handleError(error);
-        }
     });
 }
 function extractFunctionOrComputed(node, obj, k, v) {
@@ -1700,8 +1715,6 @@ function activateNodeFunction(node, lazyFn) {
     // let curTarget$: Observable<any>;
     let update;
     let wasPromise;
-    let timeoutRetry;
-    const attemptNum = { current: 0 };
     const activateFn = (isFunction(node) ? node : lazyFn);
     const doRetry = () => { var _a; return (_a = node.state) === null || _a === void 0 ? void 0 : _a.refreshNum.set((v) => v + 1); };
     let activatedValue;
@@ -1762,20 +1775,10 @@ function activateNodeFunction(node, lazyFn) {
         if (!wasPromise || !globalState.isLoadingRemote$.peek()) {
             if (wasPromise) {
                 if (node.activationState) {
-                    const { retry, initial } = node.activationState;
-                    let onError;
-                    if (retry) {
-                        if (timeoutRetry === null || timeoutRetry === void 0 ? void 0 : timeoutRetry.current) {
-                            clearTimeout(timeoutRetry.current);
-                        }
-                        const { handleError, timeout } = setupRetry(retry, doRetry, attemptNum);
-                        onError = handleError;
-                        timeoutRetry = timeout;
-                        node.activationState.onError = onError;
-                    }
+                    const { initial } = node.activationState;
                     if (value && isPromise(value)) {
                         // Extract the promise to make it set the value/error when it comes in
-                        extractPromise(node, value, update, onError);
+                        extractPromise(node, value, update);
                     }
                     // Set this to undefined only if it's replacing the activation function,
                     // so we don't overwrite it if it already has real data from either local
@@ -1785,9 +1788,8 @@ function activateNodeFunction(node, lazyFn) {
                     }
                 }
                 else if (node.activated) {
-                    let onError;
                     // Extract the promise to make it set the value/error when it comes in
-                    extractPromise(node, value, update, onError);
+                    extractPromise(node, value, update);
                     // Set this to undefined only if it's replacing the activation function,
                     // so we don't overwrite it if it already has real data from either local
                     // cache or a previous run
@@ -1824,23 +1826,21 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
     let isSettingFromSubscribe = false;
     let _mode = 'set';
     if (node.activationState) {
-        const { onSet, subscribe, get: getFn, initial, retry, waitFor } = node.activationState;
-        // TODO Should this have lastSync and value somehow?
-        const run = () => getFn({ updateLastSync: noop, setMode: (mode) => (_mode = mode), lastSync: undefined, value: undefined });
+        const { onSet, subscribe, get: getFn, initial } = node.activationState;
         value = getFn
-            ? waitFor
-                ? new Promise((resolve) => {
-                    whenReady(waitFor, () => {
-                        delete node.activationState.waitFor;
-                        resolve(run());
-                    });
-                })
-                : run()
+            ? runWithRetry(node, { attemptNum: 0 }, () => {
+                return getFn({
+                    updateLastSync: noop,
+                    setMode: (mode) => (_mode = mode),
+                    lastSync: undefined,
+                    value: undefined,
+                });
+            })
             : undefined;
+        // TODO Should this have lastSync and value somehow?
         if (value == undefined || value === null) {
             value = initial;
         }
-        let timeoutRetry;
         if (onSet) {
             let allChanges = [];
             let latestValue = undefined;
@@ -1868,33 +1868,28 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
                     globalState.pendingNodes.delete(node);
                     runNumber++;
                     const thisRunNumber = runNumber;
-                    const attemptNum = { current: 0 };
                     const run = () => {
                         if (thisRunNumber !== runNumber) {
                             // set may get called multiple times before it loads so ignore any previous runs
                             return;
                         }
-                        let onError;
-                        if (retry) {
-                            if (timeoutRetry === null || timeoutRetry === void 0 ? void 0 : timeoutRetry.current) {
-                                clearTimeout(timeoutRetry.current);
-                            }
-                            const { handleError, timeout } = setupRetry(retry, run, attemptNum);
-                            onError = handleError;
-                            timeoutRetry = timeout;
-                        }
-                        isSetting = true;
-                        batch(() => onSet({
-                            value,
-                            changes,
-                            getPrevious,
-                            node,
-                            update,
-                            refresh,
-                            onError,
-                            fromSubscribe: isSettingFromSubscribe,
-                        }), () => {
-                            isSetting = false;
+                        return runWithRetry(node, { attemptNum: 0 }, () => {
+                            return new Promise((resolve, reject) => {
+                                isSetting = true;
+                                batch(() => onSet({
+                                    value,
+                                    changes,
+                                    getPrevious,
+                                    node,
+                                    update,
+                                    refresh,
+                                    onError: reject,
+                                    fromSubscribe: isSettingFromSubscribe,
+                                }), () => {
+                                    isSetting = false;
+                                    resolve();
+                                });
+                            });
                         });
                     };
                     whenReady(node.state.isLoaded, run);
@@ -2220,10 +2215,10 @@ const internal = {
     observableFns,
     optimized,
     peek,
+    runWithRetry,
     set,
     setAtPath,
     setNodeValue,
-    setupRetry,
     symbolActivated,
     symbolDelete,
 };