@legendapp/state 2.2.0-next.33 → 2.2.0-next.35

package/index.js

@@ -15,7 +15,10 @@ function isFunction(obj) {
 }
 function isPrimitive(arg) {
     const type = typeof arg;
-    return arg !== undefined && type !== 'object' && type !== 'function';
+    return arg !== undefined && (isDate(arg) || (type !== 'object' && type !== 'function'));
+}
+function isDate(obj) {
+    return obj instanceof Date;
 }
 function isSymbol(obj) {
     return typeof obj === 'symbol';
@@ -104,7 +107,8 @@ function setNodeValue(node, newValue) {
     // If setting an observable, set a link to the observable instead
     if (isObservable(newValue) && !isComputed(newValue)) {
         const val = newValue;
-        node.lazy = () => val;
+        node.lazy = true;
+        node.lazyFn = () => val;
         newValue = undefined;
     }
     try {
@@ -140,12 +144,6 @@ function getNodeValue(node) {
     }
     return child;
 }
-const cloneFunction = (originalFunction) => {
-    const length = originalFunction.length;
-    return length > 1
-        ? (arg1, arg2) => originalFunction(arg1, arg2)
-        : (...args) => originalFunction(...args);
-};
 function getChildNode(node, key, asFunction) {
     var _a;
     // Get the child by key
@@ -158,20 +156,16 @@ function getChildNode(node, key, asFunction) {
             key,
             lazy: true,
         };
-        if (asFunction) {
-            child = Object.assign(cloneFunction(asFunction), 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.activationState) {
+            const { lookup } = node.activationState;
+            if (lookup) {
+                asFunction = lookup.bind(node, key);
             }
         }
+        if (asFunction) {
+            child = Object.assign(() => { }, child);
+            child.lazyFn = asFunction;
+        }
         if (!node.children) {
             node.children = new Map();
         }
@@ -194,17 +188,19 @@ function ensureNodeValue(node) {
 }
 function findIDKey(obj, node) {
     var _a, _b;
-    let idKey = isObject(obj)
-        ? 'id' in obj
-            ? 'id'
-            : 'key' in obj
-                ? 'key'
-                : '_id' in obj
-                    ? '_id'
-                    : '__id' in obj
-                        ? '__id'
-                        : undefined
-        : undefined;
+    let idKey = isObservable(obj)
+        ? undefined
+        : isObject(obj)
+            ? 'id' in obj
+                ? 'id'
+                : 'key' in obj
+                    ? 'key'
+                    : '_id' in obj
+                        ? '_id'
+                        : '__id' in obj
+                            ? '__id'
+                            : undefined
+            : undefined;
     if (!idKey && node.parent) {
         const k = node.key + '_keyExtractor';
         const keyExtractor = (_b = (_a = node.functions) === null || _a === void 0 ? void 0 : _a.get(k)) !== null && _b !== void 0 ? _b : getNodeValue(node.parent)[node.key + '_keyExtractor'];
@@ -215,11 +211,9 @@ 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);
@@ -494,7 +488,8 @@ function createObservable(value, makePrimitive, extractPromise, createObject, cr
         lazy: true,
     };
     if (valueIsFunction) {
-        node = Object.assign(cloneFunction(value), node);
+        node = Object.assign(() => { }, node);
+        node.lazyFn = value;
     }
     const prim = makePrimitive || isActualPrimitive(value);
     const obs = prim
@@ -960,7 +955,6 @@ function runWithRetry(node, state, fn) {
                     resolve(val);
                 })
                     .catch(() => {
-                    node.activationState.persistedRetry = true;
                     state.attemptNum++;
                     if (timeoutRetry) {
                         clearTimeout(timeoutRetry);
@@ -971,6 +965,9 @@ function runWithRetry(node, state, fn) {
                             run();
                         });
                     }
+                })
+                    .finally(() => {
+                    node.activationState.persistedRetry = false;
                 });
             };
             run();
@@ -1153,7 +1150,11 @@ function updateNodes(parent, obj, prevValue) {
                         ? idField(value)
                         : value[idField]
                     : undefined;
-                let child = getChildNode(parent, key);
+                let child = getChildNode(parent, key, isFunction(value) ? value : undefined);
+                if (child.linkedToNode && (isFunction(value) || isObservable(value))) {
+                    reactivateNode(child, value);
+                    peek(child);
+                }
                 // 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) {
@@ -1183,7 +1184,7 @@ function updateNodes(parent, obj, prevValue) {
                 if (isDiff) {
                     // Array has a new / modified element
                     // If object iterate through its children
-                    if (isFunction(value)) {
+                    if (isFunction(value) || isObservable(value)) {
                         extractFunctionOrComputed(parent, obj, key, value);
                     }
                     else if (isPrimitive(value)) {
@@ -1259,6 +1260,7 @@ 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) {
@@ -1442,7 +1444,7 @@ const proxyHandler = {
     },
     apply(target, thisArg, argArray) {
         // If it's a function call it as a function
-        return Reflect.apply(target, thisArg, argArray);
+        return Reflect.apply(target.lazyFn || target, thisArg, argArray);
     },
 };
 function set(node, newValue) {
@@ -1675,6 +1677,9 @@ function extractFunctionOrComputed(node, obj, k, v) {
         if (childNode === null || childNode === void 0 ? void 0 : childNode.isComputed) {
             extractFunction(node, k, v, childNode);
         }
+        else if (isObservable(v)) {
+            extractFunction(node, k, v);
+        }
         else {
             return true;
         }
@@ -1696,6 +1701,7 @@ function peek(node) {
     // If node is not yet lazily computed go do that
     const lazy = node.lazy;
     if (lazy) {
+        const lazyFn = node.lazyFn;
         delete node.lazy;
         if (isFunction(node) || isFunction(lazy)) {
             if (node.parent) {
@@ -1704,7 +1710,7 @@ function peek(node) {
                     delete parentValue[node.key];
                 }
             }
-            value = activateNodeFunction(node, lazy);
+            value = activateNodeFunction(node, lazyFn);
         }
     }
     if (lazy || node.needsExtract) {
@@ -1718,13 +1724,23 @@ function peek(node) {
     checkActivate(node);
     return value;
 }
+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.lazyFn = lazyFn;
+    node.lazy = true;
+}
 function activateNodeFunction(node, lazyFn) {
     // let prevTarget$: Observable<any>;
     // let curTarget$: Observable<any>;
     let update;
     let wasPromise;
     let ignoreThisUpdate;
-    const activateFn = (isFunction(node) ? node : lazyFn);
+    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 = [];
@@ -1733,8 +1749,8 @@ function activateNodeFunction(node, lazyFn) {
         node.dirtyFn = refreshFn;
         globalState.dirtyNodes.add(node);
     }
-    observe(() => {
-        var _a, _b, _c, _d;
+    node.activatedObserveDispose = observe(() => {
+        var _a, _b, _c, _d, _e, _f;
         // const params = createNodeActivationParams(node);
         // Run the function at this node
         let value = activateFn();
@@ -1766,22 +1782,28 @@ function activateNodeFunction(node, lazyFn) {
         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,
-                        refresh: doRetry,
-                    })) !== null && _c !== void 0 ? _c : activated.initial;
+                if ((_c = (_b = node.state) === null || _b === void 0 ? void 0 : _b.peek()) === null || _c === void 0 ? void 0 : _c.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;
+                }
             }
             else {
                 ignoreThisUpdate = true;
             }
         }
+        // value is undefined if it's in a persisted retry
         wasPromise = wasPromise || isPromise(value);
-        get(getNode((_d = node.state) === null || _d === void 0 ? void 0 : _d.refreshNum));
+        get(getNode((_f = node.state) === null || _f === void 0 ? void 0 : _f.refreshNum));
         return value;
     }, (e) => {
         if (!ignoreThisUpdate) {
@@ -1897,9 +1919,10 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
                             };
                             return new Promise((resolve, reject) => {
                                 isSetting = true;
+                                let isProm = false;
                                 batch(() => {
                                     try {
-                                        return onSet({
+                                        const val = onSet({
                                             value,
                                             changes,
                                             getPrevious,
@@ -1910,13 +1933,19 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
                                             cancelRetry,
                                             fromSubscribe: isSettingFromSubscribe,
                                         });
+                                        isProm = isPromise(val);
+                                        if (isProm) {
+                                            val.then(resolve).catch(reject);
+                                        }
                                     }
                                     catch (e) {
                                         reject(e);
                                     }
                                 }, () => {
-                                    isSetting = false;
-                                    resolve();
+                                    if (!isProm) {
+                                        isSetting = false;
+                                        resolve();
+                                    }
                                 });
                             });
                         });
@@ -1982,6 +2011,7 @@ const activateNodeBase = (globalState.activateNode = function activateNodeBase(n
     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);
@@ -1993,8 +2023,9 @@ function setToObservable(node, value) {
         }
         linkedNode.linkedFromNodes.add(node);
         peek(linkedNode);
-        onChange(linkedNode, ({ value: newValue }) => {
-            value = newValue;
+        (_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