@legendapp/state 2.0.0-next.3 → 2.0.0-next.4

package/index.js

@@ -163,7 +163,7 @@ function setNodeValue(node, newValue) {
     if (parentNode.root.locked && parentNode.root.set) {
         parentNode.root.set(parentNode.root._);
     }
-    return { prevValue, newValue };
+    return { prevValue, newValue, parentValue };
 }
 const arrNodeKeys = [];
 function getNodeValue(node) {
@@ -573,55 +573,50 @@ function setInObservableAtPath(obs, path, value, mode) {
 function mergeIntoObservable(target, ...sources) {
     beginBatch();
     globalState.isMerging = true;
-    const value = _mergeIntoObservable(target, ...sources);
+    for (let i = 0; i < sources.length; i++) {
+        target = _mergeIntoObservable(target, sources[i]);
+    }
     globalState.isMerging = false;
     endBatch();
-    return value;
+    return target;
 }
-function _mergeIntoObservable(target, ...sources) {
+function _mergeIntoObservable(target, source) {
     var _a;
-    if (!sources.length)
-        return target;
-    for (let u = 0; u < sources.length; u++) {
-        const source = sources[u];
-        const needsSet = isObservable(target);
-        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)) {
-            for (const key in source) {
-                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];
-                }
-                else {
-                    const isObj = isObject(sourceValue);
-                    const isArr = !isObj && isArray(sourceValue);
-                    const targetChild = target[key];
-                    if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
-                        if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
-                            target[key] = sourceValue;
-                        }
-                        else {
-                            _mergeIntoObservable(targetChild, sourceValue);
-                        }
+    const needsSet = isObservable(target);
+    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)) {
+        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];
+            }
+            else {
+                const isObj = isObject(sourceValue);
+                const isArr = !isObj && isArray(sourceValue);
+                const targetChild = target[key];
+                if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
+                    if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
+                        target[key] = sourceValue;
                     }
                     else {
-                        // TODO: It should not be possible for targetChild to be a non-observable, but it was happening in Legend.
-                        // It would be good to track down why that was happening and remove this check.
-                        needsSet && isFunction(targetChild.set)
-                            ? targetChild.set(sourceValue)
-                            : (target[key] = sourceValue);
+                        _mergeIntoObservable(targetChild, sourceValue);
                     }
                 }
+                else {
+                    needsSet
+                        ? targetChild.set(sourceValue)
+                        : (target[key] = sourceValue);
+                }
             }
         }
-        else if (source !== undefined) {
-            needsSet ? target.set(source) : (target = source);
-        }
+    }
+    else if (source !== undefined) {
+        needsSet ? target.set(source) : (target = source);
     }
     return target;
 }
@@ -684,11 +679,6 @@ function onChange(node, callback, options = {}) {
         noArgs,
     };
     listeners.add(listener);
-    let parent = node.parent;
-    while (parent && !parent.descendantHasListener) {
-        parent.descendantHasListener = true;
-        parent = parent.parent;
-    }
     if (initial) {
         const value = getNodeValue(node);
         callback({
@@ -917,75 +907,74 @@ function updateNodes(parent, obj, prevValue) {
         hasADiff = hasADiff || (keys === null || keys === void 0 ? void 0 : keys.length) !== (keysPrev === null || keysPrev === void 0 ? void 0 : keysPrev.length);
         const isArrDiff = hasADiff;
         let didMove = false;
-        if (parent.descendantHasListener || !hasADiff) {
-            for (let i = 0; i < length; i++) {
-                const key = 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];
-                let isDiff = value !== prev;
-                if (isDiff) {
-                    const id = idField && value
-                        ? isIdFieldFunction
-                            ? idField(value)
-                            : value[idField]
-                        : undefined;
-                    let child = getChildNode(parent, key);
-                    // Detect moves within an array. Need to move the original proxy to the new position to keep
-                    // the proxy stable, so that listeners to this node will be unaffected by the array shift.
-                    if (isArr && id !== undefined) {
-                        // Find the previous position of this element in the array
-                        const prevChild = id !== undefined ? prevChildrenById === null || prevChildrenById === void 0 ? void 0 : prevChildrenById.get(id) : undefined;
-                        if (!prevChild) {
-                            // This id was not in the array before so it does not need to notify children
-                            isDiff = false;
-                            hasADiff = true;
-                        }
-                        else if (prevChild !== undefined && prevChild.key !== key) {
-                            const valuePrevChild = prevValue[prevChild.key];
-                            // If array length changed then move the original node to the current position.
-                            // That should be faster than notifying every single element that
-                            // it's in a new position.
-                            if (isArrDiff) {
-                                child = prevChild;
-                                parent.children.delete(child.key);
-                                child.key = key;
-                                moved.push([key, child]);
-                            }
-                            didMove = true;
-                            // And check for diff against the previous value in the previous position
-                            isDiff = valuePrevChild !== value;
-                        }
+        for (let i = 0; i < length; i++) {
+            const key = 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];
+            let isDiff = value !== prev;
+            if (isDiff) {
+                extractFunctionOrComputed(parent, obj, key, value);
+                const id = idField && value
+                    ? isIdFieldFunction
+                        ? idField(value)
+                        : value[idField]
+                    : undefined;
+                let child = getChildNode(parent, key);
+                // Detect moves within an array. Need to move the original proxy to the new position to keep
+                // the proxy stable, so that listeners to this node will be unaffected by the array shift.
+                if (isArr && id !== undefined) {
+                    // Find the previous position of this element in the array
+                    const prevChild = id !== undefined ? prevChildrenById === null || prevChildrenById === void 0 ? void 0 : prevChildrenById.get(id) : undefined;
+                    if (!prevChild) {
+                        // This id was not in the array before so it does not need to notify children
+                        isDiff = false;
+                        hasADiff = true;
                     }
-                    if (isDiff) {
-                        // Array has a new / modified element
-                        // If object iterate through its children
-                        if (isPrimitive(value)) {
-                            hasADiff = true;
-                        }
-                        else {
-                            // Always need to updateNodes so we notify through all children
-                            const updatedNodes = (!hasADiff || !!child.descendantHasListener) && updateNodes(child, value, prev);
-                            hasADiff = hasADiff || updatedNodes;
+                    else if (prevChild !== undefined && prevChild.key !== key) {
+                        const valuePrevChild = prevValue[prevChild.key];
+                        // If array length changed then move the original node to the current position.
+                        // That should be faster than notifying every single element that
+                        // it's in a new position.
+                        if (isArrDiff) {
+                            child = prevChild;
+                            parent.children.delete(child.key);
+                            child.key = key;
+                            moved.push([key, child]);
                         }
+                        didMove = true;
+                        // And check for diff against the previous value in the previous position
+                        isDiff = valuePrevChild !== value;
                     }
-                    if (isDiff || !isArrDiff) {
-                        // Notify for this child if this element is different and it has listeners
-                        // Or if the position changed in an array whose length did not change
-                        // But do not notify child if the parent is an array with changing length -
-                        // the array's listener will cover it
-                        if (child.listeners || child.listenersImmediate) {
-                            notify(child, value, prev, 0, !isArrDiff);
-                        }
+                }
+                if (isDiff) {
+                    // Array has a new / modified element
+                    // If object iterate through its children
+                    if (isPrimitive(value)) {
+                        hasADiff = true;
+                    }
+                    else {
+                        // Always need to updateNodes so we notify through all children
+                        const updatedNodes = updateNodes(child, value, prev);
+                        hasADiff = hasADiff || updatedNodes;
                     }
                 }
-            }
-            if (moved) {
-                for (let i = 0; i < moved.length; i++) {
-                    const [key, child] = moved[i];
-                    parent.children.set(key, child);
+                if (isDiff || !isArrDiff) {
+                    // Notify for this child if this element is different and it has listeners
+                    // Or if the position changed in an array whose length did not change
+                    // But do not notify child if the parent is an array with changing length -
+                    // the array's listener will cover it
+                    if (child.listeners || child.listenersImmediate) {
+                        notify(child, value, prev, 0, !isArrDiff);
+                    }
                 }
             }
         }
+        if (moved) {
+            for (let i = 0; i < moved.length; i++) {
+                const [key, child] = moved[i];
+                parent.children.set(key, child);
+            }
+        }
         // The full array does not need to re-render if the length is the same
         // So don't notify shallow listeners
         retValue = hasADiff || didMove;
@@ -1198,10 +1187,7 @@ const proxyHandler = {
     },
 };
 function set(node, newValue) {
-    if (isPromise(newValue)) {
-        newValue.then((v) => set(node, v)).catch((error) => set(node, { error }));
-    }
-    else if (node.parent) {
+    if (node.parent) {
         return setKey(node.parent, node.key, newValue);
     }
     else {
@@ -1241,12 +1227,13 @@ function setKey(node, key, newValue, level) {
     // Get the child node for updating and notifying
     const childNode = isRoot ? node : getChildNode(node, key);
     // Set the raw value on the parent object
-    const { newValue: savedValue, prevValue } = setNodeValue(childNode, newValue);
-    const isFunc = isFunction(newValue);
+    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, newValue);
     return isFunc ? savedValue : isRoot ? getProxy(node) : getProxy(node, key);
 }
 function assign(node, value) {
@@ -1372,13 +1359,48 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
 }
 function extractPromise(node, value) {
     value.status = 'pending';
-    value.catch((error) => {
-        set(node, { error, status: 'rejected' });
-    });
-    value.then((value) => {
+    value
+        .then((value) => {
         set(node, value);
+    })
+        .catch((error) => {
+        set(node, { error, status: 'rejected' });
     });
 }
+const __devExtractFunctionsAndComputedsNodes = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test' ? new Set() : undefined;
+function extractFunctionOrComputed(node, obj, k, v) {
+    if (isPromise(v)) {
+        extractPromise(getChildNode(node, k), v);
+    }
+    else if (typeof v === 'function') {
+        extractFunction(node, k, v);
+    }
+    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;
+        }
+    }
+}
+function extractFunctionsAndComputeds(node, obj) {
+    if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
+        if (__devExtractFunctionsAndComputedsNodes.has(obj)) {
+            console.error('[legend-state] Circular reference detected in object. You may want to use opaqueObject to stop traversing child nodes.', obj);
+            return false;
+        }
+        __devExtractFunctionsAndComputedsNodes.add(obj);
+    }
+    for (const k in obj) {
+        const v = obj[k];
+        if (v && extractFunctionOrComputed(node, obj, k, v) && !v[symbolOpaque]) {
+            extractFunctionsAndComputeds(getChildNode(node, k), v);
+        }
+    }
+}
 
 const fns = ['get', 'set', 'peek', 'onChange', 'toggle'];
 function ObservablePrimitiveClass(node) {
@@ -1421,35 +1443,6 @@ ObservablePrimitiveClass.prototype.delete = function () {
     return this;
 };
 
-const __devExtractFunctionsAndComputedsNodes = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test' ? new Set() : undefined;
-function extractFunctionsAndComputeds(node, obj) {
-    if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-        if (__devExtractFunctionsAndComputedsNodes.has(obj)) {
-            console.error('[legend-state] Circular reference detected in object. You may want to use opaqueObject to stop traversing child nodes.', obj);
-            return false;
-        }
-        __devExtractFunctionsAndComputedsNodes.add(obj);
-    }
-    for (const k in obj) {
-        const v = obj[k];
-        if (isPromise(v)) {
-            extractPromise(getChildNode(node, k), v);
-        }
-        else if (typeof v === 'function') {
-            extractFunction(node, k, v);
-        }
-        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 if (!v[symbolOpaque]) {
-                extractFunctionsAndComputeds(getChildNode(node, k), obj[k]);
-            }
-        }
-    }
-}
 function createObservable(value, makePrimitive) {
     const valueIsPromise = isPromise(value);
     const root = {