@legendapp/state 2.2.0-next.7 → 2.2.0-next.9

package/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var types = require('@babel/types');
+
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 function isArray(obj) {
     return Array.isArray(obj);
@@ -55,6 +57,7 @@ const symbolGetNode = Symbol('getNode');
 const symbolDelete = /* @__PURE__ */ Symbol('delete');
 const symbolOpaque = Symbol('opaque');
 const optimized = Symbol('optimized');
+const symbolActivated = Symbol('activated');
 // TODOV3 Remove these
 const extraPrimitiveActivators = new Map();
 const extraPrimitiveProps = new Map();
@@ -158,8 +161,16 @@ function getChildNode(node, key, asFunction) {
         if (asFunction) {
             child = Object.assign(cloneFunction(asFunction), child);
         }
-        else if (node.proxyFn2) {
-            child = Object.assign(node.proxyFn2.bind(node, key), child);
+        else {
+            if (node.activationState) {
+                const { lookup } = node.activationState;
+                if (lookup) {
+                    child = Object.assign(lookup.bind(node, key), child);
+                    if (isFunction(child)) {
+                        extractFunction(node, key, child);
+                    }
+                }
+            }
         }
         if (!node.children) {
             node.children = new Map();
@@ -204,9 +215,11 @@ function findIDKey(obj, node) {
     return idKey;
 }
 function extractFunction(node, key, fnOrComputed, computedChildNode) {
+    var _a;
     if (!node.functions) {
         node.functions = new Map();
     }
+    (_a = node.children) === null || _a === void 0 ? void 0 : _a.delete(key);
     node.functions.set(key, fnOrComputed);
     if (computedChildNode) {
         computedChildNode.parentOther = getChildNode(node, key);
@@ -217,6 +230,12 @@ function extractFunction(node, key, fnOrComputed, computedChildNode) {
     }
 }
 
+function activated(params) {
+    return (() => ({
+        [symbolActivated]: params,
+    }));
+}
+
 let timeout;
 let numInBatch = 0;
 let isRunningBatch = false;
@@ -452,13 +471,37 @@ 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);
 }
 function computeSelector(selector, e, retainObservable) {
     let c = selector;
-    if (isFunction(c)) {
+    if (!isObservable(c) && isFunction(c)) {
         c = e ? c(e) : c();
     }
     return isObservable(c) && !retainObservable ? c.get() : c;
@@ -563,7 +606,9 @@ function _mergeIntoObservable(target, source) {
             const key = keys[i];
             const sourceValue = source[key];
             if (sourceValue === symbolDelete) {
-                needsSet && ((_a = target[key]) === null || _a === void 0 ? void 0 : _a.delete) ? target[key].delete() : delete target[key];
+                needsSet && ((_a = target[key]) === null || _a === void 0 ? void 0 : _a.delete)
+                    ? target[key].delete()
+                    : delete target[key];
             }
             else {
                 const isObj = isObject(sourceValue);
@@ -807,6 +852,40 @@ 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;
+        };
+    }
+    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)) {
@@ -861,64 +940,6 @@ function whenReady(predicate, effect) {
     return _when(predicate, effect, true);
 }
 
-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 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;
-        };
-    }
-    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 };
-}
-
 const ArrayModifiers = new Set([
     'copyWithin',
     'fill',
@@ -1396,12 +1417,14 @@ function setKey(node, key, newValue, level) {
             console.warn(`[legend-state] Set an HTMLElement into state. You probably don't want to do that.`);
         }
     }
+    const isRoot = !node.parent && key === '_';
+    // TODOv3 root locking will be removed with old computeds
     if (node.root.locked && !node.root.set) {
         // This happens when modifying a locked observable such as a computed.
         // If merging this could be happening deep in a hierarchy so we don't want to throw errors so we'll just do nothing.
         // This could happen during persistence local load for example.
         if (globalState.isMerging) {
-            return;
+            return isRoot ? getProxy(node) : getProxy(node, key);
         }
         else {
             throw new Error(process.env.NODE_ENV === 'development'
@@ -1409,7 +1432,9 @@ function setKey(node, key, newValue, level) {
                 : '[legend-state] Modified locked observable');
         }
     }
-    const isRoot = !node.parent && key === '_';
+    if (node.parent && !getNodeValue(node)) {
+        return set(node, { [key]: newValue });
+    }
     // Get the child node for updating and notifying
     const childNode = isRoot ? node : getChildNode(node, key, isFunction(newValue) ? newValue : undefined);
     // Set the raw value on the parent object
@@ -1595,19 +1620,17 @@ function get(node, options) {
     return peek(node);
 }
 function peek(node) {
-    const value = getNodeValue(node);
+    let value = getNodeValue(node);
     // If node is not yet lazily computed go do that
     const lazy = node.lazy;
     if (lazy) {
         delete node.lazy;
         if (isFunction(node) || isFunction(lazy)) {
-            activateNodeFunction(node, lazy);
+            value = activateNodeFunction(node, lazy);
         }
-        else {
-            for (const key in value) {
-                if (hasOwnProperty.call(value, key)) {
-                    extractFunctionOrComputed(node, value, key, value[key]);
-                }
+        for (const key in value) {
+            if (hasOwnProperty.call(value, key)) {
+                extractFunctionOrComputed(node, value, key, value[key]);
             }
         }
     }
@@ -1615,138 +1638,112 @@ function peek(node) {
     checkActivate(node);
     return value;
 }
-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 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 (!state.subscriber) {
-            state.subscriber = fn;
-        }
-    };
-    const cache = (fn) => {
-        if (!state.cacheOptions) {
-            state.cacheOptions = isFunction(fn) ? fn() : fn;
-        }
-        return new Promise((resolve) => {
-            const wait = () => {
-                if (node.state) {
-                    when(node.state.isLoadedLocal, () => {
-                        const dateModified = node.state.dateModified.get();
-                        resolve({ dateModified, value: peek(node) });
-                    });
-                }
-                else {
-                    queueMicrotask(wait);
-                }
-            };
-            wait();
-        });
-    };
-    const retry = (params) => {
-        if (!state.retryOptions) {
-            state.retryOptions = params || {};
-        }
-    };
-    // The proxy function simply marks the node as a proxy with this function
-    // so that child nodes will be created with this function, and then simply
-    // activated as a function
-    const proxy = (fn) => {
-        node.proxyFn2 = fn;
-    };
-    return {
-        onSet,
-        proxy,
-        cache,
-        retry,
-        subscribe,
-        updateLastSync,
-        obs$: getProxy(node),
-    };
-}
 function activateNodeFunction(node, lazyFn) {
-    let prevTarget$;
-    let curTarget$;
+    // let prevTarget$: Observable<any>;
+    // let curTarget$: Observable<any>;
     let update;
     let wasPromise;
     let timeoutRetry;
     const attemptNum = { current: 0 };
-    const activator = (isFunction(node) ? node : lazyFn);
-    const refresh = () => node.state.refreshNum.set((v) => v + 1);
+    const activateFn = (isFunction(node) ? node : lazyFn);
+    const refresh = () => { var _a; return (_a = node.state) === null || _a === void 0 ? void 0 : _a.refreshNum.set((v) => v + 1); };
+    let activatedValue;
     observe(() => {
-        const params = createNodeActivationParams(node);
+        var _a, _b, _c, _d;
+        // const params = createNodeActivationParams(node);
         // Run the function at this node
-        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
+        let value = activateFn();
+        // If target is an observable, make this node a link to it
         if (isObservable(value)) {
-            prevTarget$ = curTarget$;
-            curTarget$ = value;
-            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.
-                    // This is a workaround for linked objects because it might not notify
-                    // if setting a property of an object
-                    // TODO: Is there a way to not do this? Or at least only do it in a
-                    // small subset of cases?
-                    setNodeValue(getNode(curTarget$), getPrevious());
-                    // Set the value on the curTarget
-                    curTarget$.set(newValue);
-                }
-            });
-            // Get the value from the observable because we still want the raw value
-            // for the effect.
-            value = value.get();
+            // If the computed is a proxy to another observable
+            // link it to the target observable
+            const linkedNode = getNode(value);
+            const prevNode = node.linkedToNode;
+            node.linkedToNode = linkedNode;
+            if (!linkedNode.linkedFromNodes) {
+                linkedNode.linkedFromNodes = new Set();
+            }
+            linkedNode.linkedFromNodes.add(node);
+            onChange(linkedNode, ({ value: newValue }) => {
+                value = newValue;
+                set(node, value);
+            }, { initial: true });
+            // If the target observable is different then notify for the change
+            if (prevNode) {
+                const value = getNodeValue(linkedNode);
+                const prevValue = getNodeValue(prevNode);
+                notify(node, value, prevValue, 0);
+            }
         }
-        else {
-            wasPromise = isPromise(value) ? value : undefined;
+        if (isFunction(value)) {
+            value = value();
+        }
+        const activated = value === null || value === void 0 ? void 0 : value[symbolActivated];
+        if (activated) {
+            node.activationState = activated;
+            value = activated.initial;
         }
+        wasPromise = isPromise(value);
         // 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 isCached = !!((_a = node.activationState) === null || _a === void 0 ? void 0 : _a.cache);
+            wasPromise = wasPromise || !!isCached;
             const activateNodeFn = wasPromise ? globalState.activateNode : activateNodeBase;
-            update = activateNodeFn(node, refresh, !!wasPromise, value).update;
+            const { update: newUpdate, value: newValue } = activateNodeFn(node, refresh, !!wasPromise, value);
+            update = newUpdate;
+            value = newValue;
+        }
+        else if (node.activationState) {
+            if (!node.activationState.persistedRetry) {
+                const activated = node.activationState;
+                value = (_c = (_b = activated.get) === null || _b === void 0 ? void 0 : _b.call(activated, {})) !== null && _c !== void 0 ? _c : activated.initial;
+            }
         }
-        node.state.refreshNum.get();
+        wasPromise = wasPromise || isPromise(value);
+        (_d = node.state) === null || _d === void 0 ? void 0 : _d.refreshNum.get();
         return value;
     }, ({ value }) => {
         if (!globalState.isLoadingRemote$.peek()) {
             if (wasPromise) {
-                const { retryOptions } = node.activationState;
-                let onError;
-                if (retryOptions) {
-                    if (timeoutRetry) {
-                        clearTimeout(timeoutRetry.current);
+                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, refresh, attemptNum);
+                        onError = handleError;
+                        timeoutRetry = timeout;
+                        node.activationState.onError = onError;
+                    }
+                    if (value && isPromise(value)) {
+                        // Extract the promise to make it set the value/error when it comes in
+                        extractPromise(node, value, update, onError);
+                    }
+                    // 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, initial !== null && initial !== void 0 ? initial : undefined);
                     }
-                    const { handleError, timeout } = setupRetry(retryOptions, refresh, attemptNum);
-                    onError = handleError;
-                    timeoutRetry = timeout;
                 }
-                // Extract the promise to make it set the value/error when it comes in
-                extractPromise(node, value, update, onError);
-                // 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 if (node.activated) {
+                    let onError;
+                    // Extract the promise to make it set the value/error when it comes in
+                    extractPromise(node, value, update, onError);
+                    // 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 {
+                activatedValue = value;
                 set(node, value);
                 node.state.assign({
                     isLoaded: true,
@@ -1755,49 +1752,100 @@ function activateNodeFunction(node, lazyFn) {
             }
         }
     }, { immediate: true, fromComputed: true });
+    return activatedValue;
 }
-const activateNodeBase = (globalState.activateNode = function activateNodeBase(node, refresh, wasPromise) {
-    const { onSetFn, subscriber } = node.activationState;
-    let isSetting = false;
+const activateNodeBase = (globalState.activateNode = function activateNodeBase(node, refresh, wasPromise, value) {
     if (!node.state) {
         node.state = createObservable({
             isLoaded: false,
         }, false, extractPromise, getProxy);
     }
-    if (onSetFn) {
-        const doSet = (params) => {
-            // Don't call the set if this is the first value coming in
-            if (!isSetting) {
-                if ((!wasPromise || node.state.isLoaded.get()) &&
-                    (params.changes.length > 1 || !isFunction(params.changes[0].prevAtPath))) {
-                    isSetting = true;
-                    batch(() => onSetFn(params, { update }), () => {
-                        isSetting = false;
+    let isSetting = false;
+    let isSettingFromSubscribe = false;
+    let _mode = 'set';
+    if (node.activationState) {
+        const { onSet, subscribe, get, initial, retry, waitFor } = node.activationState;
+        // @ts-expect-error asdf
+        const run = () => get({ updateLastSync: types.noop, setMode: (mode) => (_mode = mode) });
+        value = get
+            ? waitFor
+                ? new Promise((resolve) => {
+                    whenReady(waitFor, () => {
+                        resolve(run());
                     });
+                })
+                : run()
+            : undefined;
+        if (value == undefined || value === null) {
+            value = initial;
+        }
+        let timeoutRetry;
+        if (onSet) {
+            const doSet = (params) => {
+                // Don't call the set if this is the first value coming in
+                if (!isSetting || isSettingFromSubscribe) {
+                    if (node.state.isLoaded.get() &&
+                        (params.changes.length > 1 || !isFunction(params.changes[0].prevAtPath))) {
+                        const attemptNum = { current: 0 };
+                        const run = () => {
+                            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(params, {
+                                node,
+                                update,
+                                refresh,
+                                onError,
+                                fromSubscribe: isSettingFromSubscribe,
+                            }), () => {
+                                isSetting = false;
+                            });
+                        };
+                        run();
+                    }
                 }
-            }
-        };
-        onChange(node, doSet, wasPromise ? undefined : { immediate: true });
-    }
-    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 retryOptions without setting up persistence first');
+            };
+            onChange(node, doSet, wasPromise ? undefined : { immediate: true });
+        }
+        if (process.env.NODE_ENV === 'development' && node.activationState.cache) {
+            // TODO Better message
+            console.log('[legend-state] Using cache without setting up persistence first');
+        }
+        if (process.env.NODE_ENV === 'development' && node.activationState.retry) {
+            // TODO Better message
+            console.log('[legend-state] Using retry without setting up persistence first');
+        }
+        if (subscribe) {
+            const updateFromSubscribe = (params) => {
+                isSettingFromSubscribe = true;
+                update(params);
+                isSettingFromSubscribe = false;
+            };
+            subscribe({ node, update: updateFromSubscribe, refresh });
+        }
     }
-    const update = ({ value }) => {
+    const update = ({ value, mode }) => {
         // 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) {
-            set(node, value);
+            isSetting = true;
+            if (_mode === 'assign' || mode === 'assign') {
+                assign(node, value);
+            }
+            else {
+                set(node, value);
+            }
+            isSetting = false;
         }
     };
-    if (subscriber) {
-        subscriber({ update, refresh });
-    }
-    return { update };
+    return { update, value };
 });
 
 const fns = ['get', 'set', 'peek', 'onChange', 'toggle'];
@@ -2025,10 +2073,12 @@ const internal = {
     setAtPath,
     setNodeValue,
     setupRetry,
+    symbolActivated,
     symbolDelete,
 };
 
 exports.ObservablePrimitiveClass = ObservablePrimitiveClass;
+exports.activated = activated;
 exports.batch = batch;
 exports.beginBatch = beginBatch;
 exports.beginTracking = beginTracking;