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

package/index.js

@@ -8,7 +8,7 @@ function isString(obj) {
     return typeof obj === 'string';
 }
 function isObject(obj) {
-    return !!obj && typeof obj === 'object' && !isArray(obj);
+    return !!obj && typeof obj === 'object' && !(obj instanceof Date) && !isArray(obj);
 }
 function isFunction(obj) {
     return typeof obj === 'function';
@@ -55,6 +55,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();
@@ -63,6 +64,8 @@ const globalState = {
     isMerging: false,
     isLoadingRemote$: undefined,
     activateNode: undefined,
+    pendingNodes: new Map(),
+    dirtyNodes: new Set(),
 };
 function isObservable(obs) {
     return !!obs && !!obs[symbolGetNode];
@@ -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;
@@ -241,23 +260,28 @@ function isArraySubset(mainArr, subsetArr) {
     return true;
 }
 function createPreviousHandlerInner(value, changes) {
-    // Clones the current state and inject the previous data at the changed path
-    let clone = value ? JSON.parse(JSON.stringify(value)) : {};
-    for (let i = 0; i < changes.length; i++) {
-        const { path, prevAtPath } = changes[i];
-        let o = clone;
-        if (path.length > 0) {
-            let i;
-            for (i = 0; i < path.length - 1; i++) {
-                o = o[path[i]];
+    try {
+        // Clones the current state and inject the previous data at the changed path
+        let clone = value ? JSON.parse(JSON.stringify(value)) : {};
+        for (let i = 0; i < changes.length; i++) {
+            const { path, prevAtPath } = changes[i];
+            let o = clone;
+            if (path.length > 0) {
+                let i;
+                for (i = 0; i < path.length - 1; i++) {
+                    o = o[path[i]];
+                }
+                o[path[i]] = prevAtPath;
+            }
+            else {
+                clone = prevAtPath;
             }
-            o[path[i]] = prevAtPath;
-        }
-        else {
-            clone = prevAtPath;
         }
+        return clone;
+    }
+    catch (_a) {
+        return undefined;
     }
-    return clone;
 }
 function createPreviousHandler(value, changes) {
     // Create a function that generates the previous state
@@ -366,6 +390,13 @@ function batchNotifyChanges(changesInBatch, immediate) {
     });
 }
 function runBatch() {
+    const dirtyNodes = Array.from(globalState.dirtyNodes);
+    globalState.dirtyNodes.clear();
+    dirtyNodes.forEach((node) => {
+        var _a;
+        (_a = node.dirtyFn) === null || _a === void 0 ? void 0 : _a.call(node);
+        node.dirtyFn = undefined;
+    });
     // Save batch locally and reset _batchMap first because a new batch could begin while looping over callbacks.
     // This can happen with observableComputed for example.
     const map = _batchMap;
@@ -482,7 +513,7 @@ function isEvent(obs) {
 }
 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;
@@ -581,14 +612,15 @@ function _mergeIntoObservable(target, source) {
     const targetValue = needsSet ? target.peek() : target;
     const isTargetArr = isArray(targetValue);
     const isTargetObj = !isTargetArr && isObject(targetValue);
-    if ((isTargetObj && isObject(source) && !isEmpty(targetValue)) ||
-        (isTargetArr && isArray(source) && targetValue.length > 0)) {
+    if ((isTargetObj && isObject(source) && !isEmpty(targetValue)) || (isTargetArr && targetValue.length > 0)) {
         const keys = Object.keys(source);
         for (let i = 0; i < keys.length; i++) {
             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);
@@ -777,7 +809,7 @@ function trackSelector(selector, update, observeEvent, observeOptions, createRes
         dispose = setupTracking(nodes, updateFn, false, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.immediate);
         resubscribe = createResubscribe ? () => setupTracking(nodes, updateFn) : undefined;
     }
-    return { value, dispose, resubscribe };
+    return { value, nodes, dispose, resubscribe };
 }
 
 function observe(selectorOrRun, reactionOrOptions, options) {
@@ -802,9 +834,11 @@ function observe(selectorOrRun, reactionOrOptions, options) {
         delete e.value;
         // Dispose listeners from previous run
         dispose === null || dispose === void 0 ? void 0 : dispose();
-        const { dispose: _dispose, value } = trackSelector(selectorOrRun, update, e, options);
+        const { dispose: _dispose, value, nodes } = trackSelector(selectorOrRun, update, e, options);
         dispose = _dispose;
         e.value = value;
+        e.nodes = nodes;
+        e.refresh = update;
         if (e.onCleanupReaction) {
             e.onCleanupReaction();
             e.onCleanupReaction = undefined;
@@ -812,7 +846,9 @@ function observe(selectorOrRun, reactionOrOptions, options) {
         endBatch();
         // Call the reaction if there is one and the value changed
         if (reaction &&
-            ((options === null || options === void 0 ? void 0 : options.fromComputed) || ((e.num > 0 || !isEvent(selectorOrRun)) && e.previous !== e.value))) {
+            ((options === null || options === void 0 ? void 0 : options.fromComputed) ||
+                ((e.num > 0 || !isEvent(selectorOrRun)) &&
+                    (e.previous !== e.value || typeof e.value === 'object')))) {
             reaction(e);
         }
         // Update the previous value
@@ -832,6 +868,115 @@ function observe(selectorOrRun, reactionOrOptions, options) {
     };
 }
 
+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;
+    let effectValue;
+    // 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
+        effectValue = 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 effect ? effectValue : 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(isPromise(effectValue) ? effectValue.then((value) => value) : 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 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',
     'fill',
@@ -872,19 +1017,24 @@ if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
 }
 function collectionSetter(node, target, prop, ...args) {
     var _a;
-    const prevValue = (isArray(target) && target.slice()) || target;
-    const ret = target[prop].apply(target, args);
-    if (node) {
-        const hasParent = isChildNodeValue(node);
-        const key = hasParent ? node.key : '_';
-        const parentValue = hasParent ? getNodeValue(node.parent) : node.root;
-        // Set the object to the previous value first
-        parentValue[key] = prevValue;
-        // Then set with the new value so it notifies with the correct prevValue
-        setKey((_a = node.parent) !== null && _a !== void 0 ? _a : node, key, target);
-    }
-    // Return the original value
-    return ret;
+    if (prop === 'push') {
+        setKey(node, target.length + '', args[0]);
+    }
+    else {
+        const prevValue = target.slice();
+        const ret = target[prop].apply(target, args);
+        if (node) {
+            const hasParent = isChildNodeValue(node);
+            const key = hasParent ? node.key : '_';
+            const parentValue = hasParent ? getNodeValue(node.parent) : node.root;
+            // Set the object to the previous value first
+            parentValue[key] = prevValue;
+            // Then set with the new value so it notifies with the correct prevValue
+            setKey((_a = node.parent) !== null && _a !== void 0 ? _a : node, key, target);
+        }
+        // Return the original value
+        return ret;
+    }
 }
 function getKeys(obj, isArr, isMap) {
     return isArr ? undefined : obj ? (isMap ? Array.from(obj.keys()) : Object.keys(obj)) : [];
@@ -919,8 +1069,9 @@ function updateNodes(parent, obj, prevValue) {
     let prevChildrenById;
     let moved;
     const isMap = obj instanceof Map;
+    const isPrevMap = prevValue instanceof Map;
     const keys = getKeys(obj, isArr, isMap);
-    const keysPrev = getKeys(prevValue, isArr, isMap);
+    const keysPrev = getKeys(prevValue, isArr, isPrevMap);
     const length = ((_a = (keys || obj)) === null || _a === void 0 ? void 0 : _a.length) || 0;
     const lengthPrev = ((_b = (keysPrev || prevValue)) === null || _b === void 0 ? void 0 : _b.length) || 0;
     let idField;
@@ -972,7 +1123,7 @@ function updateNodes(parent, obj, prevValue) {
             if (!keys.includes(key)) {
                 hasADiff = true;
                 const child = getChildNode(parent, key);
-                const prev = isMap ? prevValue.get(key) : prevValue[key];
+                const prev = isPrevMap ? prevValue.get(key) : prevValue[key];
                 if (prev !== undefined) {
                     if (!isPrimitive(prev)) {
                         updateNodes(child, undefined, prev);
@@ -991,7 +1142,7 @@ function updateNodes(parent, obj, prevValue) {
         for (let i = 0; i < length; i++) {
             const key = isArr ? i + '' : keys[i];
             const value = isMap ? obj.get(key) : obj[key];
-            const prev = isMap ? prevValue === null || prevValue === void 0 ? void 0 : prevValue.get(key) : prevValue === null || prevValue === void 0 ? void 0 : prevValue[key];
+            const prev = isPrevMap ? prevValue === null || prevValue === void 0 ? void 0 : prevValue.get(key) : prevValue === null || prevValue === void 0 ? void 0 : prevValue[key];
             let isDiff = value !== prev;
             if (isDiff) {
                 const id = idField && value
@@ -1029,7 +1180,10 @@ function updateNodes(parent, obj, prevValue) {
                 if (isDiff) {
                     // Array has a new / modified element
                     // If object iterate through its children
-                    if (isPrimitive(value)) {
+                    if (isFunction(value)) {
+                        extractFunctionOrComputed(parent, obj, key, value);
+                    }
+                    else if (isPrimitive(value)) {
                         hasADiff = true;
                     }
                     else {
@@ -1077,6 +1231,15 @@ function getProxy(node, p, asFunction) {
     // Create a proxy if not already cached and return it
     return (node.proxy || (node.proxy = new Proxy(node, proxyHandler)));
 }
+function flushPending() {
+    // Need to short circuit the computed batching because the user called get() or peek()
+    // in which case the set needs to run immediately so that the values are up to date.
+    if (globalState.pendingNodes.size > 0) {
+        const nodes = Array.from(globalState.pendingNodes.values());
+        globalState.pendingNodes.clear();
+        nodes.forEach((fn) => fn());
+    }
+}
 const proxyHandler = {
     get(node, p, receiver) {
         var _a;
@@ -1104,6 +1267,9 @@ const proxyHandler = {
         const fn = observableFns.get(p);
         // If this is an observable function, call it
         if (fn) {
+            if (p === 'get' || p === 'peek') {
+                flushPending();
+            }
             return function (a, b, c) {
                 const l = arguments.length;
                 // Array call and apply are slow so micro-optimize this hot path.
@@ -1209,10 +1375,6 @@ const proxyHandler = {
                 return vProp;
             }
         }
-        // TODOV3: Remove "state"
-        if (vProp === undefined && (p === 'state' || p === '_state') && node.state) {
-            return node.state;
-        }
         // Return an observable proxy to the property
         return getProxy(node, p);
     },
@@ -1304,12 +1466,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'
@@ -1317,18 +1481,28 @@ 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
-    const { newValue: savedValue, prevValue, parentValue } = setNodeValue(childNode, newValue);
-    const isFunc = isFunction(savedValue);
-    const isPrim = isPrimitive(savedValue) || savedValue instanceof Date;
-    if (savedValue !== prevValue) {
-        updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level);
+    if (isObservable(newValue)) {
+        setToObservable(childNode, newValue);
     }
-    extractFunctionOrComputed(node, parentValue, key, savedValue);
-    return isFunc ? savedValue : isRoot ? getProxy(node) : getProxy(node, key);
+    else {
+        // Set the raw value on the parent object
+        const { newValue: savedValue, prevValue, parentValue } = setNodeValue(childNode, newValue);
+        const isFunc = isFunction(savedValue);
+        const isPrim = isPrimitive(savedValue) || savedValue instanceof Date;
+        if (savedValue !== prevValue) {
+            updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level);
+        }
+        extractFunctionOrComputed(node, parentValue, key, savedValue);
+        if (isFunc) {
+            return savedValue;
+        }
+    }
+    return isRoot ? getProxy(node) : getProxy(node, key);
 }
 function assign(node, value) {
     const proxy = getProxy(node);
@@ -1433,7 +1607,7 @@ function handlerMapSet(node, p, value) {
 function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRoot, level) {
     if (!childNode)
         childNode = node;
-    // Make sure we don't call too many listeners for ever property set
+    // Make sure we don't call too many listeners for every property set
     beginBatch();
     let hasADiff = isPrim;
     let whenOptimizedOnlyIf = false;
@@ -1454,7 +1628,7 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
     }
     endBatch();
 }
-function extractPromise(node, value) {
+function extractPromise(node, value, setter) {
     if (!node.state) {
         node.state = createObservable({
             isLoaded: false,
@@ -1462,26 +1636,38 @@ function extractPromise(node, value) {
     }
     value
         .then((value) => {
-        set(node, value);
-        node.state.isLoaded.set(true);
+        setter ? setter({ value }) : set(node, value);
+        node.state.assign({
+            isLoaded: true,
+            error: undefined,
+        });
     })
         .catch((error) => {
         node.state.error.set(error);
     });
 }
 function extractFunctionOrComputed(node, obj, k, v) {
+    var _a;
     if (isPromise(v)) {
-        extractPromise(getChildNode(node, k), v);
+        const childNode = getChildNode(node, k);
+        extractPromise(childNode, v);
+        setNodeValue(childNode, undefined);
     }
     else if (typeof v === 'function') {
+        const childNode = (_a = node.children) === null || _a === void 0 ? void 0 : _a.get(k);
         extractFunction(node, k, v);
-        delete obj[k];
+        // If child was previously activated, then peek the new linked observable to make sure it's activated
+        if (childNode && !childNode.lazy) {
+            if (isObservable(v)) {
+                const vNode = getNode(v);
+                peek(vNode);
+            }
+        }
     }
     else if (typeof v == 'object' && v !== null && v !== undefined) {
         const childNode = getNode(v);
         if (childNode === null || childNode === void 0 ? void 0 : childNode.isComputed) {
             extractFunction(node, k, v, childNode);
-            delete obj[k];
         }
         else {
             return true;
@@ -1495,20 +1681,29 @@ function get(node, options) {
     return peek(node);
 }
 function peek(node) {
-    const value = getNodeValue(node);
+    if (node.dirtyFn) {
+        node.dirtyFn();
+        globalState.dirtyNodes.delete(node);
+        node.dirtyFn = undefined;
+    }
+    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);
-        }
-        else {
-            for (const key in value) {
-                if (hasOwnProperty.call(value, key)) {
-                    extractFunctionOrComputed(node, value, key, value[key]);
+            if (node.parent) {
+                const parentValue = getNodeValue(node.parent);
+                if (parentValue) {
+                    delete parentValue[node.key];
                 }
             }
+            value = activateNodeFunction(node, lazy);
+        }
+        for (const key in value) {
+            if (hasOwnProperty.call(value, key)) {
+                extractFunctionOrComputed(node, value, key, value[key]);
+            }
         }
     }
     // Check if computed needs to activate
@@ -1516,137 +1711,272 @@ function peek(node) {
     return value;
 }
 function activateNodeFunction(node, lazyFn) {
-    let setter;
+    // let prevTarget$: Observable<any>;
+    // let curTarget$: Observable<any>;
     let update;
-    let subscriber;
-    const lastSync = {};
-    let cacheOptions;
-    // The onSet function handles the observable being set
-    // and forwards the set elsewhere
-    const onSet = (setterParam) => {
-        setter = setterParam;
-    };
-    // The onSet function handles the observable being set
-    // and forwards the set elsewhere
-    const updateLastSync = (fn) => {
-        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;
-        }
-    };
-    const cache = (fn) => {
-        if (!cacheOptions) {
-            cacheOptions = isFunction(fn) ? fn() : fn;
-        }
-    };
-    // 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;
-    };
-    let prevTarget$;
-    let curTarget$;
-    const activator = (isFunction(node) ? node : lazyFn);
     let wasPromise;
-    let isInitial = true;
+    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;
+    let disposes = [];
+    let refreshFn;
+    function markDirty() {
+        node.dirtyFn = refreshFn;
+        globalState.dirtyNodes.add(node);
+    }
     observe(() => {
+        var _a, _b, _c, _d;
+        // const params = createNodeActivationParams(node);
         // Run the function at this node
-        let value = activator({ onSet, subscribe, proxy, cache, updateLastSync });
-        // 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;
-            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();
+            value = setToObservable(node, value);
+        }
+        if (isFunction(value)) {
+            value = value();
+        }
+        const activated = value === null || value === void 0 ? void 0 : value[symbolActivated];
+        if (activated) {
+            node.activationState = activated;
+            value = undefined;
         }
-        wasPromise = isPromise(value) ? value : undefined;
+        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, value, setter, subscriber, cacheOptions, lastSync).update;
-        }
-        if (wasPromise) {
-            value = undefined;
+            const { update: newUpdate, value: newValue } = activateNodeFn(node, doRetry, !!wasPromise, value);
+            update = newUpdate;
+            value = newValue !== null && newValue !== void 0 ? newValue : activated === null || activated === void 0 ? void 0 : activated.initial;
+        }
+        else if (node.activationState) {
+            if (!node.activationState.persistedRetry && !node.activationState.waitFor) {
+                const activated = node.activationState;
+                // TODO Should this have lastSync and value somehow?
+                value =
+                    (_c = (_b = activated.get) === null || _b === void 0 ? void 0 : _b.call(activated, {
+                        updateLastSync: noop,
+                        setMode: noop,
+                        lastSync: undefined,
+                        value: undefined,
+                    })) !== null && _c !== void 0 ? _c : activated.initial;
+            }
         }
+        wasPromise = wasPromise || isPromise(value);
+        get(getNode((_d = node.state) === null || _d === void 0 ? void 0 : _d.refreshNum));
         return value;
-    }, ({ value }) => {
-        if (!globalState.isLoadingRemote$.peek()) {
+    }, (e) => {
+        const { value, nodes, refresh } = e;
+        refreshFn = refresh;
+        if (!wasPromise || !globalState.isLoadingRemote$.peek()) {
             if (wasPromise) {
-                wasPromise.then((newValue) => {
-                    update({ value: newValue });
-                    node.state.isLoaded.set(true);
-                });
-                if (isInitial && isFunction(getNodeValue(node))) {
-                    set(node, value);
+                if (node.activationState) {
+                    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);
+                    }
+                    // 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);
+                    }
+                }
+                else if (node.activated) {
+                    // Extract the promise to make it set the value/error when it comes in
+                    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
+                    if (isFunction(getNodeValue(node))) {
+                        setNodeValue(node, undefined);
+                    }
                 }
             }
             else {
+                activatedValue = value;
                 set(node, value);
-                node.state.isLoaded.set(true);
+                node.state.assign({
+                    isLoaded: true,
+                    error: undefined,
+                });
             }
         }
-        isInitial = false;
-    }, { immediate: true, fromComputed: true });
+        disposes.forEach((fn) => fn());
+        disposes = [];
+        nodes === null || nodes === void 0 ? void 0 : nodes.forEach(({ node }) => {
+            disposes.push(onChange(node, markDirty, { immediate: true }));
+        });
+        e.cancel = true;
+    }, { fromComputed: true });
+    return activatedValue;
 }
-const activateNodeBase = (globalState.activateNode = function activateNodeBase(node, newValue, setter, subscriber, cacheOptions) {
-    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 (setter) {
-        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;
-                    batch(() => setter(params), () => {
-                        isSetting = false;
-                    });
+    let isSetting = false;
+    let isSettingFromSubscribe = false;
+    let _mode = 'set';
+    if (node.activationState) {
+        const { onSet, subscribe, get: getFn, initial } = node.activationState;
+        value = getFn
+            ? 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;
+        }
+        if (onSet) {
+            let allChanges = [];
+            let latestValue = undefined;
+            let runNumber = 0;
+            const runChanges = (listenerParams) => {
+                // Don't call the set if this is the first value coming in
+                if (allChanges.length > 0) {
+                    let changes;
+                    let value;
+                    let getPrevious;
+                    if (listenerParams) {
+                        changes = listenerParams.changes;
+                        value = listenerParams.value;
+                        getPrevious = listenerParams.getPrevious;
+                    }
+                    else {
+                        // If this is called by flushPending then get the change array
+                        // that we've been building up.
+                        changes = allChanges;
+                        value = latestValue;
+                        getPrevious = createPreviousHandler(value, changes);
+                    }
+                    allChanges = [];
+                    latestValue = undefined;
+                    globalState.pendingNodes.delete(node);
+                    runNumber++;
+                    const thisRunNumber = runNumber;
+                    const run = () => {
+                        if (thisRunNumber !== runNumber) {
+                            // set may get called multiple times before it loads so ignore any previous runs
+                            return;
+                        }
+                        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);
                 }
-            }
-        };
-        onChange(node, doSet, { immediate: true });
-    }
-    if (process.env.NODE_ENV === 'development' && cacheOptions) {
-        // TODO Better message
-        console.log('[legend-state] Using cacheOption without setting up persistence first');
+            };
+            const onChangeImmediate = ({ value, changes }) => {
+                if (!isSetting || isSettingFromSubscribe) {
+                    if (changes.length > 1 || !isFunction(changes[0].prevAtPath)) {
+                        latestValue = value;
+                        if (allChanges.length > 0) {
+                            changes = changes.filter((change) => !isArraySubset(allChanges[0].path, change.path));
+                        }
+                        allChanges.push(...changes);
+                        globalState.pendingNodes.set(node, runChanges);
+                    }
+                }
+            };
+            // Create an immediate listener to mark this node as pending. Then actually run
+            // the changes at the end of the batch so everything is properly batched.
+            // However, this can be short circuited if the user calls get() or peek()
+            // in which case the set needs to run immediately so that the values are up to date.
+            onChange(node, onChangeImmediate, { immediate: true });
+            onChange(node, runChanges);
+        }
+        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) => {
+                whenReady(node.state.isLoaded, () => {
+                    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 if (_mode === 'merge' || mode === 'merge') {
+                mergeIntoObservable(getProxy(node), value);
+            }
+            else {
+                set(node, value);
+            }
+            isSetting = false;
         }
     };
-    const isProm = isPromise(newValue);
-    if (isProm) {
-        extractPromise(node, newValue);
-    }
-    if (subscriber) {
-        subscriber({ update });
-    }
-    return { update };
+    return { update, value };
 });
+function setToObservable(node, value) {
+    // If the computed is a proxy to another observable
+    // link it to the target observable
+    const linkedNode = getNode(value);
+    if (linkedNode !== node) {
+        const prevNode = node.linkedToNode;
+        node.linkedToNode = linkedNode;
+        if (!linkedNode.linkedFromNodes) {
+            linkedNode.linkedFromNodes = new Set();
+        }
+        linkedNode.linkedFromNodes.add(node);
+        peek(linkedNode);
+        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);
+        }
+    }
+    return value;
+}
 
 const fns = ['get', 'set', 'peek', 'onChange', 'toggle'];
 function ObservablePrimitiveClass(node) {
@@ -1663,8 +1993,14 @@ function proto(key, fn) {
         return fn.call(this, this._node, ...args);
     };
 }
-proto('peek', peek);
-proto('get', get);
+proto('peek', (node) => {
+    flushPending();
+    return peek(node);
+});
+proto('get', (node, options) => {
+    flushPending();
+    return get(node, options);
+});
 proto('set', set);
 proto('onChange', onChange);
 // Getters
@@ -1695,6 +2031,16 @@ function observable(value) {
 function observablePrimitive(value) {
     return createObservable(value, true, extractPromise, getProxy, ObservablePrimitiveClass);
 }
+function syncState(obs) {
+    const node = getNode(obs);
+    if (!node.state) {
+        peek(node);
+    }
+    if (!node.state) {
+        node.state = observable({});
+    }
+    return node.state;
+}
 globalState.isLoadingRemote$ = observable(false);
 
 function computed(compute, set$1) {
@@ -1859,60 +2205,6 @@ 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,
@@ -1923,13 +2215,16 @@ const internal = {
     observableFns,
     optimized,
     peek,
+    runWithRetry,
     set,
     setAtPath,
     setNodeValue,
+    symbolActivated,
     symbolDelete,
 };
 
 exports.ObservablePrimitiveClass = ObservablePrimitiveClass;
+exports.activated = activated;
 exports.batch = batch;
 exports.beginBatch = beginBatch;
 exports.beginTracking = beginTracking;
@@ -1974,6 +2269,7 @@ exports.setInObservableAtPath = setInObservableAtPath;
 exports.setSilently = setSilently;
 exports.setupTracking = setupTracking;
 exports.symbolDelete = symbolDelete;
+exports.syncState = syncState;
 exports.trackSelector = trackSelector;
 exports.tracking = tracking;
 exports.updateTracking = updateTracking;