@legendapp/state 2.2.0-next.0 → 2.2.0-next.3

package/index.d.ts

@@ -24,12 +24,7 @@ export declare const internal: {
         isLoadingLocal: boolean;
         isMerging: boolean;
         isLoadingRemote$: import("./src/observableInterfaces").ObservablePrimitiveBaseFns<boolean> & import("./src/observableInterfaces").ObservablePrimitiveBooleanFns<boolean>;
-        onChangeRemote: (cb: () => void) => void;
-        activateNode: (node: import("./src/observableInterfaces").NodeValue, newValue: any, setter: (value: any) => void, subscriber: (params: {
-            update: any;
-        }) => void, cacheOptions: import("./src/observableInterfaces").CacheOptions<any>) => {
-            update: any;
-        };
+        activateNode: (node: import("./src/observableInterfaces").NodeValue, refresh: () => void, newValue: any) => void;
     };
     observableFns: Map<string, (node: import("./src/observableInterfaces").NodeValue, ...args: any[]) => any>;
     optimized: symbol;

package/index.js

@@ -62,7 +62,6 @@ const globalState = {
     isLoadingLocal: false,
     isMerging: false,
     isLoadingRemote$: undefined,
-    onChangeRemote: undefined,
     activateNode: undefined,
 };
 function isObservable(obs) {
@@ -1472,7 +1471,9 @@ function extractPromise(node, value) {
 }
 function extractFunctionOrComputed(node, obj, k, v) {
     if (isPromise(v)) {
-        extractPromise(getChildNode(node, k), v);
+        const childNode = getChildNode(node, k);
+        extractPromise(childNode, v);
+        setNodeValue(childNode, undefined);
     }
     else if (typeof v === 'function') {
         extractFunction(node, k, v);
@@ -1516,26 +1517,36 @@ function peek(node) {
     checkActivate(node);
     return value;
 }
-function activateNodeFunction(node, lazyFn) {
-    let setter;
-    let update;
-    let subscriber;
-    let cacheOptions;
+function createNodeActivationParams(node) {
+    node.activationState = {
+        lastSync: {},
+    };
+    const state = node.activationState;
+    // The onSet function handles the observable being set
+    // and forwards the set elsewhere
+    const onSet = (onSetFnParam) => {
+        state.onSetFn = onSetFnParam;
+    };
     // The onSet function handles the observable being set
     // and forwards the set elsewhere
-    const onSet = (setterParam) => {
-        setter = setterParam;
+    const updateLastSync = (fn) => {
+        state.lastSync.value = fn;
     };
     // The subscribe function runs a function that listens to
     // a data source and sends updates into the observable
     const subscribe = (fn) => {
-        if (!subscriber) {
-            subscriber = fn;
+        if (!state.subscriber) {
+            state.subscriber = fn;
         }
     };
     const cache = (fn) => {
-        if (!cacheOptions) {
-            cacheOptions = isFunction(fn) ? fn() : fn;
+        if (!state.cacheOptions) {
+            state.cacheOptions = isFunction(fn) ? fn() : fn;
+        }
+    };
+    const retry = (params) => {
+        if (!state.retryOptions) {
+            state.retryOptions = params;
         }
     };
     // The proxy function simply marks the node as a proxy with this function
@@ -1544,20 +1555,31 @@ function activateNodeFunction(node, lazyFn) {
     const proxy = (fn) => {
         node.proxyFn2 = fn;
     };
+    return {
+        onSet,
+        proxy,
+        cache,
+        retry,
+        subscribe,
+        updateLastSync,
+    };
+}
+function activateNodeFunction(node, lazyFn) {
     let prevTarget$;
     let curTarget$;
     const activator = (isFunction(node) ? node : lazyFn);
     let wasPromise;
-    let isInitial = true;
+    const refresh = () => node.state.refreshNum.set((v) => v + 1);
     observe(() => {
+        const params = createNodeActivationParams(node);
         // Run the function at this node
-        let value = activator({ onSet, subscribe, proxy, cache });
+        let value = activator(params);
         // If target is an observable, get() it to make sure we listen to its changes
         // and set up an onSet to write changes back to it
         if (isObservable(value)) {
             prevTarget$ = curTarget$;
             curTarget$ = value;
-            onSet(({ value: newValue, getPrevious }) => {
+            params.onSet(({ value: newValue, getPrevious }) => {
                 // Don't set the target observable if the target has changed since the last run
                 if (!prevTarget$ || curTarget$ === prevTarget$) {
                     // Set the node value back to what it was before before setting it.
@@ -1574,25 +1596,28 @@ function activateNodeFunction(node, lazyFn) {
             // for the effect.
             value = value.get();
         }
-        wasPromise = isPromise(value) ? value : undefined;
+        else {
+            wasPromise = isPromise(value) ? value : undefined;
+        }
+        // Activate this node if not activated already (may be called recursively)
+        // TODO: Is calling recursively bad? If so can it be fixed?
         if (!node.activated) {
             node.activated = true;
             const activateNodeFn = wasPromise ? globalState.activateNode : activateNodeBase;
-            update = activateNodeFn(node, value, setter, subscriber, cacheOptions).update;
-        }
-        if (wasPromise) {
-            value = undefined;
+            activateNodeFn(node, refresh, value);
         }
+        node.state.refreshNum.get();
         return value;
     }, ({ value }) => {
         if (!globalState.isLoadingRemote$.peek()) {
             if (wasPromise) {
-                wasPromise.then((newValue) => {
-                    update({ value: newValue });
-                    node.state.isLoaded.set(true);
-                });
-                if (isInitial && isFunction(getNodeValue(node))) {
-                    set(node, value);
+                // Extract the promise to make it set the value/error when it comes in
+                extractPromise(node, value);
+                // 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
+                if (isFunction(getNodeValue(node))) {
+                    setNodeValue(node, undefined);
                 }
             }
             else {
@@ -1600,24 +1625,23 @@ function activateNodeFunction(node, lazyFn) {
                 node.state.isLoaded.set(true);
             }
         }
-        isInitial = false;
     }, { immediate: true, fromComputed: true });
 }
-const activateNodeBase = (globalState.activateNode = function activateNodeBase(node, newValue, setter, subscriber, cacheOptions) {
+const activateNodeBase = (globalState.activateNode = function activateNodeBase(node, refresh) {
+    const { onSetFn, subscriber } = node.activationState;
     let isSetting = false;
     if (!node.state) {
         node.state = createObservable({
             isLoaded: false,
         }, false, extractPromise, getProxy);
     }
-    if (setter) {
+    if (onSetFn) {
         const doSet = (params) => {
             // Don't call the set if this is the first value coming in
             if (!isSetting) {
                 if (params.changes.length > 1 || !isFunction(params.changes[0].prevAtPath)) {
                     isSetting = true;
-                    params.isRemote = globalState.isLoadingRemote$.peek();
-                    batch(() => setter(params), () => {
+                    batch(() => onSetFn(params), () => {
                         isSetting = false;
                     });
                 }
@@ -1625,25 +1649,24 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
         };
         onChange(node, doSet, { immediate: true });
     }
-    if (process.env.NODE_ENV === 'development' && cacheOptions) {
+    if (process.env.NODE_ENV === 'development' && node.activationState.cacheOptions) {
+        // TODO Better message
+        console.log('[legend-state] Using cacheOptions without setting up persistence first');
+    }
+    if (process.env.NODE_ENV === 'development' && node.activationState.retryOptions) {
         // TODO Better message
-        console.log('[legend-state] Using cacheOption without setting up persistence first');
+        console.log('[legend-state] Using retryOptions without setting up persistence first');
     }
     const update = ({ value }) => {
+        // TODO: This isSetting might not be necessary? Tests still work if removing it.
+        // Write tests that would break it if removed? I'd guess a combination of subscribe and
         if (!isSetting) {
-            globalState.onChangeRemote(() => {
-                set(node, value);
-            });
+            set(node, value);
         }
     };
-    const isProm = isPromise(newValue);
-    if (isProm) {
-        extractPromise(node, newValue);
-    }
     if (subscriber) {
-        subscriber({ update });
+        subscriber({ update, refresh });
     }
-    return { update };
 });
 
 const fns = ['get', 'set', 'peek', 'onChange', 'toggle'];
@@ -1687,60 +1710,6 @@ ObservablePrimitiveClass.prototype.delete = function () {
     return this;
 };
 
-function _when(predicate, effect, checkReady) {
-    // If predicate is a regular Promise skip all the observable stuff
-    if (isPromise(predicate)) {
-        return effect ? predicate.then(effect) : predicate;
-    }
-    let value;
-    // Create a wrapping fn that calls the effect if predicate returns true
-    function run(e) {
-        const ret = computeSelector(predicate);
-        if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
-            value = ret;
-            // Set cancel so that observe does not track anymore
-            e.cancel = true;
-        }
-        return value;
-    }
-    function doEffect() {
-        // If value is truthy then run the effect
-        effect === null || effect === void 0 ? void 0 : effect(value);
-    }
-    // Run in an observe
-    observe(run, doEffect);
-    // If first run resulted in a truthy value just return it.
-    // It will have set e.cancel so no need to dispose
-    if (isPromise(value)) {
-        return effect ? value.then(effect) : value;
-    }
-    else if (value !== undefined) {
-        return Promise.resolve(value);
-    }
-    else {
-        // Wrap it in a promise
-        const promise = new Promise((resolve) => {
-            if (effect) {
-                const originalEffect = effect;
-                effect = (value) => {
-                    const effectValue = originalEffect(value);
-                    resolve(effectValue);
-                };
-            }
-            else {
-                effect = resolve;
-            }
-        });
-        return promise;
-    }
-}
-function when(predicate, effect) {
-    return _when(predicate, effect, false);
-}
-function whenReady(predicate, effect) {
-    return _when(predicate, effect, true);
-}
-
 function observable(value) {
     return createObservable(value, false, extractPromise, getProxy, ObservablePrimitiveClass);
 }
@@ -1748,15 +1717,6 @@ function observablePrimitive(value) {
     return createObservable(value, true, extractPromise, getProxy, ObservablePrimitiveClass);
 }
 globalState.isLoadingRemote$ = observable(false);
-globalState.onChangeRemote = function onChangeRemote(cb) {
-    when(() => !globalState.isLoadingRemote$.get(), () => {
-        // Remote changes should only update local state
-        globalState.isLoadingRemote$.set(true);
-        batch(cb, () => {
-            globalState.isLoadingRemote$.set(false);
-        });
-    });
-};
 
 function computed(compute, set$1) {
     // Create an observable for this computed variable
@@ -1920,6 +1880,60 @@ function proxy(get, set) {
     return obs;
 }
 
+function _when(predicate, effect, checkReady) {
+    // If predicate is a regular Promise skip all the observable stuff
+    if (isPromise(predicate)) {
+        return effect ? predicate.then(effect) : predicate;
+    }
+    let value;
+    // Create a wrapping fn that calls the effect if predicate returns true
+    function run(e) {
+        const ret = computeSelector(predicate);
+        if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
+            value = ret;
+            // Set cancel so that observe does not track anymore
+            e.cancel = true;
+        }
+        return value;
+    }
+    function doEffect() {
+        // If value is truthy then run the effect
+        effect === null || effect === void 0 ? void 0 : effect(value);
+    }
+    // Run in an observe
+    observe(run, doEffect);
+    // If first run resulted in a truthy value just return it.
+    // It will have set e.cancel so no need to dispose
+    if (isPromise(value)) {
+        return effect ? value.then(effect) : value;
+    }
+    else if (value !== undefined) {
+        return Promise.resolve(value);
+    }
+    else {
+        // Wrap it in a promise
+        const promise = new Promise((resolve) => {
+            if (effect) {
+                const originalEffect = effect;
+                effect = (value) => {
+                    const effectValue = originalEffect(value);
+                    resolve(effectValue);
+                };
+            }
+            else {
+                effect = resolve;
+            }
+        });
+        return promise;
+    }
+}
+function when(predicate, effect) {
+    return _when(predicate, effect, false);
+}
+function whenReady(predicate, effect) {
+    return _when(predicate, effect, true);
+}
+
 const internal = {
     ensureNodeValue,
     findIDKey,