@legendapp/state 2.2.0-next.41 → 2.2.0-next.43

package/index.d.ts

@@ -28,7 +28,7 @@ export declare const internal: {
         isLoadingLocal: boolean;
         isMerging: boolean;
         isLoadingRemote$: import("./src/observableTypes").ObservablePrimitive<boolean>;
-        activateNode: (node: import("./src/observableInterfaces").NodeValue, refresh: () => void, wasPromise: boolean, newValue: any) => {
+        activateNodePersist: (node: import("./src/observableInterfaces").NodeValue, newValue: any) => {
             update: import("./src/observableInterfaces").UpdateFn;
             value: any;
         };

package/index.js

@@ -62,14 +62,11 @@ 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();
 const globalState = {
     isLoadingLocal: false,
     isMerging: false,
     isLoadingRemote$: undefined,
-    activateNode: undefined,
+    activateNodePersist: undefined,
     pendingNodes: new Map(),
     dirtyNodes: new Set(),
 };
@@ -94,13 +91,6 @@ function setNodeValue(node, newValue) {
     const isFunc = isFunction(newValue);
     // Compute newValue if newValue is a function or an observable
     newValue = !parentNode.isAssigning && isFunc ? newValue(prevValue) : newValue;
-    // If setting an observable, set a link to the observable instead
-    if (isObservable(newValue)) {
-        const val = newValue;
-        node.lazy = true;
-        node.lazyFn = () => val;
-        newValue = undefined;
-    }
     if (!globalState.isMerging ||
         prevValue === undefined ||
         isFunction(prevValue) ||
@@ -137,7 +127,7 @@ function getNodeValue(node) {
     return child;
 }
 function getChildNode(node, key, asFunction) {
-    var _a;
+    var _a, _b;
     // Get the child by key
     let child = (_a = node.children) === null || _a === void 0 ? void 0 : _a.get(key);
     // Create the child node if it doesn't already exist
@@ -148,11 +138,9 @@ function getChildNode(node, key, asFunction) {
             key,
             lazy: true,
         };
-        if (node.activationState) {
-            const { lookup } = node.activationState;
-            if (lookup) {
-                asFunction = lookup.bind(node, key);
-            }
+        // Lookup functions are bound with the child key
+        if (((_b = node.lazyFn) === null || _b === void 0 ? void 0 : _b.length) === 1) {
+            asFunction = node.lazyFn.bind(node, key);
         }
         if (asFunction) {
             child = Object.assign(() => { }, child);
@@ -167,7 +155,7 @@ function getChildNode(node, key, asFunction) {
 }
 function ensureNodeValue(node) {
     let value = getNodeValue(node);
-    if (!value) {
+    if (!value || isFunction(value)) {
         if (isChildNodeValue(node)) {
             const parent = ensureNodeValue(node.parent);
             value = parent[node.key] = {};
@@ -322,7 +310,8 @@ function computeChangesRecursive(changesInBatch, node, value, path, pathTypes, v
     computeChangesAtNode(changesInBatch, node, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf);
     if (node.linkedFromNodes) {
         for (const linkedFromNode of node.linkedFromNodes) {
-            computeChangesAtNode(changesInBatch, linkedFromNode, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf);
+            const childNode = getNodeAtPath(linkedFromNode, path);
+            computeChangesRecursive(changesInBatch, childNode, valueAtPath, [], [], valueAtPath, prevAtPath, immediate, 0, whenOptimizedOnlyIf);
         }
     }
     // If not root notify up through parents
@@ -461,6 +450,14 @@ function endBatch(force) {
         }
     }
 }
+function getNodeAtPath(obj, path) {
+    let o = obj;
+    for (let i = 0; i < path.length; i++) {
+        const p = path[i];
+        o = getChildNode(o, p);
+    }
+    return o;
+}
 
 function createObservable(value, makePrimitive, extractPromise, createObject, createPrimitive) {
     const valueIsPromise = isPromise(value);
@@ -651,7 +648,8 @@ function setSilently(obs, newValue) {
     return setNodeValue(node, newValue).newValue;
 }
 
-function onChange(node, callback, options = {}) {
+function onChange(node, callback, options = {}, fromLinks) {
+    var _a;
     const { initial, immediate, noArgs } = options;
     const { trackingType } = options;
     let listeners = immediate ? node.listenersImmediate : node.listeners;
@@ -685,15 +683,79 @@ function onChange(node, callback, options = {}) {
             getPrevious: () => undefined,
         });
     }
-    let extraDispose;
+    let extraDisposes;
+    function addLinkedNodeListeners(childNode, cb = callback, from) {
+        // Don't add listeners for the same node more than once
+        if (!(fromLinks === null || fromLinks === void 0 ? void 0 : fromLinks.has(childNode))) {
+            fromLinks || (fromLinks = new Set());
+            fromLinks.add(from || node);
+            cb || (cb = callback);
+            const childOptions = {
+                trackingType: true,
+                ...options,
+            };
+            // onChange for the linked node
+            extraDisposes = [...(extraDisposes || []), onChange(childNode, cb, childOptions, fromLinks)];
+        }
+    }
+    // Add listeners for linked to nodes
     if (node.linkedToNode) {
-        extraDispose = onChange(node.linkedToNode, callback, options);
+        addLinkedNodeListeners(node.linkedToNode);
+    }
+    // Add listeners for linked from nodes
+    (_a = node.linkedFromNodes) === null || _a === void 0 ? void 0 : _a.forEach((linkedFromNode) => addLinkedNodeListeners(linkedFromNode));
+    // Go up through the parents and add listeners for linked from nodes
+    let parent = node.parent;
+    let pathParent = [node.key];
+    while (parent) {
+        if (parent.linkedFromNodes) {
+            for (const linkedFromNode of parent.linkedFromNodes) {
+                if (!(fromLinks === null || fromLinks === void 0 ? void 0 : fromLinks.has(linkedFromNode))) {
+                    const cb = createCb(linkedFromNode, pathParent, callback);
+                    addLinkedNodeListeners(linkedFromNode, cb, parent);
+                }
+            }
+        }
+        pathParent = [parent.key, ...pathParent];
+        parent = parent.parent;
     }
     return () => {
         listeners.delete(listener);
-        extraDispose === null || extraDispose === void 0 ? void 0 : extraDispose();
+        extraDisposes === null || extraDisposes === void 0 ? void 0 : extraDisposes.forEach((fn) => fn());
+    };
+}
+function createCb(linkedFromNode, path, callback) {
+    // Create a callback for a path that calls it with the current value at the path
+    let { valueAtPath: prevAtPath } = getValueAtPath(getNodeValue(linkedFromNode), path);
+    return function ({ value: valueA }) {
+        const { valueAtPath, pathTypes } = getValueAtPath(valueA, path);
+        if (valueAtPath !== prevAtPath) {
+            callback({
+                value: valueAtPath,
+                changes: [
+                    {
+                        path,
+                        pathTypes,
+                        prevAtPath,
+                        valueAtPath,
+                    },
+                ],
+                getPrevious: () => prevAtPath,
+            });
+        }
+        prevAtPath = valueAtPath;
     };
 }
+function getValueAtPath(obj, path) {
+    let o = obj;
+    const pathTypes = [];
+    for (let i = 0; o && i < path.length; i++) {
+        pathTypes.push(isArray(o) ? 'array' : 'object');
+        const p = path[i];
+        o = o[p];
+    }
+    return { valueAtPath: o, pathTypes };
+}
 
 function setupTracking(nodes, update, noArgs, immediate) {
     let listeners = [];
@@ -902,65 +964,6 @@ 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 createRetryTimeout(retryOptions, attemptNum, fn) {
-    const delayTime = calculateRetryDelay(retryOptions, attemptNum);
-    if (delayTime) {
-        return setTimeout(fn, delayTime);
-    }
-}
-function runWithRetry(node, state, fn) {
-    const { retry, waitFor } = node.activationState;
-    const e = { cancel: false };
-    let value = undefined;
-    if (waitFor) {
-        value = whenReady(waitFor, () => {
-            node.activationState.waitFor = undefined;
-            return fn(e);
-        });
-    }
-    else {
-        value = fn(e);
-    }
-    if (isPromise(value) && retry) {
-        let timeoutRetry;
-        return new Promise((resolve) => {
-            const run = () => {
-                value
-                    .then((val) => {
-                    node.activationState.persistedRetry = false;
-                    resolve(val);
-                })
-                    .catch(() => {
-                    state.attemptNum++;
-                    if (timeoutRetry) {
-                        clearTimeout(timeoutRetry);
-                    }
-                    if (!e.cancel) {
-                        timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
-                            value = fn(e);
-                            run();
-                        });
-                    }
-                })
-                    .finally(() => {
-                    node.activationState.persistedRetry = false;
-                });
-            };
-            run();
-        });
-    }
-    return value;
-}
-
-const noop = () => { };
 const ArrayModifiers = new Set([
     'copyWithin',
     'fill',
@@ -979,7 +982,6 @@ const ArrayLoopers = new Set([
     'find',
     'findIndex',
     'forEach',
-    'includes',
     'join',
     'map',
     'some',
@@ -1249,7 +1251,6 @@ const proxyHandler = {
         // The exception is onChange because it needs to listen to this node for changes.
         // This needs to be below peek because it activates there.
         if (node.linkedToNode && p !== 'onChange') {
-            updateTracking(node);
             return proxyHandler.get(node.linkedToNode, p, receiver);
         }
         if (value instanceof Map || value instanceof WeakMap || value instanceof Set || value instanceof WeakSet) {
@@ -1285,20 +1286,6 @@ const proxyHandler = {
         if (property) {
             return property.get(node);
         }
-        // TODOV3 Remove this
-        const isValuePrimitive = isPrimitive(value);
-        // If accessing a key that doesn't already exist, and this node has been activated with extra keys
-        // then return the values that were set. This is used by enableLegendStateReact for example.
-        if (value === undefined || value === null || isValuePrimitive) {
-            if (extraPrimitiveProps.size && (node.isActivatedPrimitive || extraPrimitiveActivators.has(p))) {
-                node.isActivatedPrimitive = true;
-                const vPrim = extraPrimitiveProps.get(p);
-                if (vPrim !== undefined) {
-                    return isFunction(vPrim) ? vPrim(getProxy(node)) : vPrim;
-                }
-            }
-        }
-        // /TODOV3 Remove this
         let vProp = value === null || value === void 0 ? void 0 : value[p];
         if (isObject(value) && value[symbolOpaque]) {
             return vProp;
@@ -1679,8 +1666,14 @@ function peek(node) {
     if (lazy) {
         const lazyFn = node.lazyFn;
         delete node.lazy;
-        if (isFunction(node) || isFunction(lazyFn)) {
-            value = activateNodeFunction(node, lazyFn);
+        if (isFunction(lazyFn)) {
+            if (lazyFn.length === 1) {
+                // This is a lookup function, so return a record object
+                value = {};
+            }
+            else {
+                value = activateNodeFunction(node, lazyFn);
+            }
         }
     }
     if (lazy || node.needsExtract) {
@@ -1695,10 +1688,8 @@ function peek(node) {
 function reactivateNode(node, lazyFn) {
     var _a, _b;
     (_a = node.activatedObserveDispose) === null || _a === void 0 ? void 0 : _a.call(node);
-    node.activatedObserveDispose = undefined;
     (_b = node.linkedToNodeDispose) === null || _b === void 0 ? void 0 : _b.call(node);
-    node.linkedToNodeDispose = undefined;
-    node.linkedToNode = undefined;
+    node.activatedObserveDispose = node.linkedToNodeDispose = node.linkedToNode = undefined;
     node.lazyFn = lazyFn;
     node.lazy = true;
 }
@@ -1709,7 +1700,6 @@ function activateNodeFunction(node, lazyFn) {
     let wasPromise;
     let ignoreThisUpdate;
     const activateFn = 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;
@@ -1718,7 +1708,7 @@ function activateNodeFunction(node, lazyFn) {
         globalState.dirtyNodes.add(node);
     }
     node.activatedObserveDispose = observe(() => {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d;
         // const params = createNodeActivationParams(node);
         // Run the function at this node
         let value = activateFn();
@@ -1740,29 +1730,25 @@ function activateNodeFunction(node, lazyFn) {
         // 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;
-            const { update: newUpdate, value: newValue } = activateNodeFn(node, doRetry, !!wasPromise, value);
+            let activateNodeFn = activateNodeBase;
+            // If this is a Synced then run it through persistence instead of base
+            if (activated === null || activated === void 0 ? void 0 : activated.synced) {
+                activateNodeFn = globalState.activateNodePersist;
+                wasPromise = true;
+            }
+            const { update: newUpdate, value: newValue } = activateNodeFn(node, 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;
-                if ((_c = (_b = node.state) === null || _b === void 0 ? void 0 : _b.peek()) === null || _c === void 0 ? void 0 : _c.sync) {
+                if ((_b = (_a = node.state) === null || _a === void 0 ? void 0 : _a.peek()) === null || _b === void 0 ? void 0 : _b.sync) {
                     node.state.sync();
                     ignoreThisUpdate = true;
                 }
                 else {
-                    value =
-                        (_e = (_d = activated.get) === null || _d === void 0 ? void 0 : _d.call(activated, {
-                            updateLastSync: noop,
-                            setMode: noop,
-                            lastSync: undefined,
-                            value: undefined,
-                            refresh: doRetry,
-                        })) !== null && _e !== void 0 ? _e : activated.initial;
+                    value = (_d = (_c = activated.get) === null || _c === void 0 ? void 0 : _c.call(activated)) !== null && _d !== void 0 ? _d : activated.initial;
                 }
             }
             else {
@@ -1771,7 +1757,6 @@ function activateNodeFunction(node, lazyFn) {
         }
         // value is undefined if it's in a persisted retry
         wasPromise = wasPromise || isPromise(value);
-        get(getNode((_f = node.state) === null || _f === void 0 ? void 0 : _f.refreshNum));
         return value;
     }, (e) => {
         if (!ignoreThisUpdate) {
@@ -1827,29 +1812,16 @@ function activateNodeFunction(node, lazyFn) {
     }, { fromComputed: true });
     return activatedValue;
 }
-const activateNodeBase = (globalState.activateNode = function activateNodeBase(node, refresh, wasPromise, value) {
+function activateNodeBase(node, value) {
     if (!node.state) {
         node.state = createObservable({
             isLoaded: false,
         }, false, extractPromise, getProxy);
     }
     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,
-                    refresh,
-                });
-            })
-            : undefined;
-        // TODO Should this have lastSync and value somehow?
+        const { onSet, get: getFn, initial } = node.activationState;
+        value = getFn === null || getFn === void 0 ? void 0 : getFn();
         if (value == undefined || value === null) {
             value = initial;
         }
@@ -1885,49 +1857,22 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
                             // set may get called multiple times before it loads so ignore any previous runs
                             return;
                         }
-                        const retryAttempts = { attemptNum: 0 };
-                        return runWithRetry(node, retryAttempts, (eventRetry) => {
-                            const cancelRetry = () => {
-                                eventRetry.cancel = true;
-                            };
-                            return new Promise((resolve, reject) => {
-                                isSetting = true;
-                                let isProm = false;
-                                batch(() => {
-                                    try {
-                                        const val = onSet({
-                                            value,
-                                            changes,
-                                            getPrevious,
-                                            node,
-                                            update,
-                                            refresh,
-                                            retryNum: retryAttempts.attemptNum,
-                                            cancelRetry,
-                                            fromSubscribe: isSettingFromSubscribe,
-                                        });
-                                        isProm = isPromise(val);
-                                        if (isProm) {
-                                            val.then(resolve).catch(reject);
-                                        }
-                                    }
-                                    catch (e) {
-                                        reject(e);
-                                    }
-                                }, () => {
-                                    if (!isProm) {
-                                        isSetting = false;
-                                        resolve();
-                                    }
-                                });
+                        isSetting = true;
+                        batch(() => {
+                            onSet({
+                                value,
+                                changes,
+                                getPrevious,
                             });
+                        }, () => {
+                            isSetting = false;
                         });
                     };
                     whenReady(node.state.isLoaded, run);
                 }
             };
             const onChangeImmediate = ({ value, changes }) => {
-                if (!isSetting || isSettingFromSubscribe) {
+                if (!isSetting) {
                     if (changes.length > 1 || !isFunction(changes[0].prevAtPath)) {
                         latestValue = value;
                         if (allChanges.length > 0) {
@@ -1945,68 +1890,32 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
             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, mode }) => {
+    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) {
             isSetting = true;
-            if (_mode === 'assign' || mode === 'assign') {
-                assign(node, value);
-            }
-            else if (_mode === 'merge' || mode === 'merge') {
-                mergeIntoObservable(getProxy(node), value);
-            }
-            else {
-                set(node, value);
-            }
+            set(node, value);
             isSetting = false;
         }
     };
     return { update, value };
-});
+}
 function setToObservable(node, value) {
     var _a;
     // If the computed is a proxy to another observable
     // link it to the target observable
     const linkedNode = getNode(value);
     if (linkedNode !== node && (linkedNode === null || linkedNode === void 0 ? void 0 : linkedNode.linkedToNode) !== node) {
-        const prevNode = node.linkedToNode;
         node.linkedToNode = linkedNode;
-        if (!linkedNode.linkedFromNodes) {
-            linkedNode.linkedFromNodes = new Set();
-        }
+        linkedNode.linkedFromNodes || (linkedNode.linkedFromNodes = new Set());
         linkedNode.linkedFromNodes.add(node);
-        peek(linkedNode);
         (_a = node.linkedToNodeDispose) === null || _a === void 0 ? void 0 : _a.call(node);
         node.linkedToNodeDispose = onChange(linkedNode, () => {
             value = peek(linkedNode);
             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);
-        }
+        }, { initial: true }, new Set([node]));
     }
     return value;
 }
@@ -2136,14 +2045,70 @@ function event() {
 }
 
 function proxy(get, set) {
-    return observable(activated({
-        lookup: (key) => set
-            ? activated({
-                get: () => get(key),
-                onSet: ({ value }) => set(key, value),
-            })
-            : get(key),
-    }));
+    return observable((key) => set
+        ? activated({
+            get: () => get(key),
+            onSet: ({ value }) => set(key, value),
+        })
+        : get(key));
+}
+
+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 createRetryTimeout(retryOptions, attemptNum, fn) {
+    const delayTime = calculateRetryDelay(retryOptions, attemptNum);
+    if (delayTime) {
+        return setTimeout(fn, delayTime);
+    }
+}
+function runWithRetry(node, state, fn) {
+    const { retry, waitFor } = node.activationState;
+    const e = { cancel: false };
+    let value = undefined;
+    if (waitFor) {
+        value = whenReady(waitFor, () => {
+            node.activationState.waitFor = undefined;
+            return fn(e);
+        });
+    }
+    else {
+        value = fn(e);
+    }
+    if (isPromise(value) && retry) {
+        let timeoutRetry;
+        return new Promise((resolve) => {
+            const run = () => {
+                value
+                    .then((val) => {
+                    node.activationState.persistedRetry = false;
+                    resolve(val);
+                })
+                    .catch(() => {
+                    state.attemptNum++;
+                    if (timeoutRetry) {
+                        clearTimeout(timeoutRetry);
+                    }
+                    if (!e.cancel) {
+                        timeoutRetry = createRetryTimeout(retry, state.attemptNum, () => {
+                            value = fn(e);
+                            run();
+                        });
+                    }
+                })
+                    .finally(() => {
+                    node.activationState.persistedRetry = false;
+                });
+            };
+            run();
+        });
+    }
+    return value;
 }
 
 const internal = {
@@ -2177,8 +2142,6 @@ exports.deconstructObjectWithPath = deconstructObjectWithPath;
 exports.endBatch = endBatch;
 exports.endTracking = endTracking;
 exports.event = event;
-exports.extraPrimitiveActivators = extraPrimitiveActivators;
-exports.extraPrimitiveProps = extraPrimitiveProps;
 exports.findIDKey = findIDKey;
 exports.getNode = getNode;
 exports.getNodeValue = getNodeValue;