@legendapp/state 2.2.0-next.74 → 2.2.0-next.76

package/helpers/time.d.ts

@@ -1,3 +1,3 @@
-declare const currentTime: import("../observableTypes").ObservablePrimitive<Date>;
-declare const currentDay: import("../observableTypes").ObservablePrimitive<Date>;
+declare const currentTime: import("@legendapp/state").ObservablePrimitive<Date>;
+declare const currentDay: import("@legendapp/state").ObservablePrimitive<Date>;
 export { currentTime, currentDay };

package/index.d.ts

@@ -5,7 +5,7 @@ export { configureLegendState } from './src/config';
 export { event } from './src/event';
 export { isObservable } from './src/globals';
 export { computeSelector, constructObjectWithPath, deconstructObjectWithPath, getObservableIndex, isObservableValueReady, mergeIntoObservable, opaqueObject, setAtPath, setInObservableAtPath, setSilently, } from './src/helpers';
-export { hasOwnProperty, isArray, isBoolean, isDate, isEmpty, isFunction, isNullOrUndefined, isObject, isPrimitive, isPromise, isString, isSymbol, } from './src/is';
+export { hasOwnProperty, isArray, isBoolean, isDate, isEmpty, isFunction, isMap, isNullOrUndefined, isNumber, isObject, isPrimitive, isPromise, isString, isSymbol, } from './src/is';
 export { observable, observablePrimitive, syncState } from './src/observable';
 export * from './src/observableInterfaces';
 export * from './src/observableTypes';

package/index.js

@@ -29,6 +29,13 @@ function isBoolean(obj) {
 function isPromise(obj) {
     return obj instanceof Promise;
 }
+function isMap(obj) {
+    return obj instanceof Map;
+}
+function isNumber(obj) {
+    const n = obj;
+    return n - n < 1;
+}
 function isEmpty(obj) {
     // Looping and returning false on the first property is faster than Object.keys(obj).length === 0
     // https://jsbench.me/qfkqv692c8
@@ -73,10 +80,10 @@ const globalState = {
     reviver: undefined,
 };
 function getPathType(value) {
-    return isArray(value) ? 'array' : value instanceof Map ? 'map' : value instanceof Set ? 'set' : 'object';
+    return isArray(value) ? 'array' : isMap(value) ? 'map' : value instanceof Set ? 'set' : 'object';
 }
 function replacer(key, value) {
-    if (value instanceof Map) {
+    if (isMap(value)) {
         return {
             __LSType: 'Map',
             value: Array.from(value.entries()), // or with spread: value: [...value]
@@ -152,12 +159,24 @@ function setNodeValue(node, newValue) {
         !((_c = (_b = node.parent) === null || _b === void 0 ? void 0 : _b.functions) === null || _c === void 0 ? void 0 : _c.get(key))) {
         try {
             parentNode.isSetting = (parentNode.isSetting || 0) + 1;
+            const useMapFn = isMap(parentValue);
             // Save the new value
             if (isDelete) {
-                delete parentValue[key];
+                if (useMapFn) {
+                    parentValue.delete(key);
+                }
+                else {
+                    delete parentValue[key];
+                }
             }
             else {
-                parentValue[key] = newValue;
+                const useMapFn = isMap(parentValue);
+                if (useMapFn) {
+                    parentValue.set(key, newValue);
+                }
+                else {
+                    parentValue[key] = newValue;
+                }
             }
         }
         finally {
@@ -177,7 +196,7 @@ function getNodeValue(node) {
     let child = node.root._;
     for (let i = count - 1; child && i >= 0; i--) {
         const key = arrNodeKeys[i];
-        child = key !== 'size' && (child instanceof Map || child instanceof WeakMap) ? child.get(key) : child[key];
+        child = key !== 'size' && (isMap(child) || child instanceof WeakMap) ? child.get(key) : child[key];
     }
     return child;
 }
@@ -279,6 +298,8 @@ function isArraySubset(mainArr, subsetArr) {
 function createPreviousHandlerInner(value, changes) {
     try {
         // Clones the current state and inject the previous data at the changed path
+        // TODO: Is this behavior similar to setAtPath or mergeIntoObservable so one
+        // of those could be used here?
         let cloned = value ? clone(value) : {};
         for (let i = 0; i < changes.length; i++) {
             const { path, prevAtPath } = changes[i];
@@ -289,7 +310,7 @@ function createPreviousHandlerInner(value, changes) {
                     o = o[path[i]];
                 }
                 const key = path[i];
-                if (o instanceof Map) {
+                if (isMap(o)) {
                     o.set(key, prevAtPath);
                 }
                 else {
@@ -432,9 +453,11 @@ 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;
+        const dirtyFn = node.dirtyFn;
+        if (dirtyFn) {
+            node.dirtyFn = undefined;
+            dirtyFn();
+        }
     });
     // Save batch locally and reset _batchMap first because a new batch could begin while looping over callbacks.
     // This can happen with computeds for example.
@@ -501,6 +524,10 @@ function getNodeAtPath(obj, path) {
     return o;
 }
 
+function linked(params) {
+    return (() => ({ [symbolLinked]: params }));
+}
+
 function createObservable(value, makePrimitive, extractPromise, createObject, createPrimitive) {
     if (isObservable(value)) {
         return value;
@@ -539,7 +566,7 @@ function computeSelector(selector, e, retainObservable) {
 function getObservableIndex(obs) {
     const node = getNode(obs);
     const n = +node.key;
-    return n - n < 1 ? +n : -1;
+    return isNumber(n) ? n : -1;
 }
 function opaqueObject(value) {
     if (value) {
@@ -999,7 +1026,13 @@ function _when(predicate, effect, checkReady) {
     // 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)) {
+        if (isPromise(ret)) {
+            value = ret;
+            // We want value to be the Promise but return undefined
+            // so it doesn't run the effect with the Promise as the value
+            return undefined;
+        }
+        else if (!isPromise(ret) && (checkReady ? isObservableValueReady(ret) : ret)) {
             value = ret;
             // Set cancel so that observe does not track anymore
             e.cancel = true;
@@ -1136,9 +1169,9 @@ function updateNodes(parent, obj, prevValue) {
     const isArr = isArray(obj);
     let prevChildrenById;
     let moved;
-    const isMap = obj instanceof Map;
-    const isPrevMap = prevValue instanceof Map;
-    const keys = getKeys(obj, isArr, isMap);
+    const isCurMap = isMap(obj);
+    const isPrevMap = isMap(prevValue);
+    const keys = getKeys(obj, isArr, isCurMap);
     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;
@@ -1211,7 +1244,7 @@ function updateNodes(parent, obj, prevValue) {
         let didMove = false;
         for (let i = 0; i < length; i++) {
             const key = isArr ? i + '' : keys[i];
-            let value = isMap ? obj.get(key) : obj[key];
+            let value = isCurMap ? obj.get(key) : obj[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 = !equals(value, prev);
             if (isDiff) {
@@ -1225,7 +1258,7 @@ function updateNodes(parent, obj, prevValue) {
                     const valueNode = getNode(value);
                     if ((existingChild === null || existingChild === void 0 ? void 0 : existingChild.linkedToNode) === valueNode) {
                         const targetValue = getNodeValue(valueNode);
-                        isMap ? obj.set(key, targetValue) : (obj[key] = targetValue);
+                        isCurMap ? obj.set(key, targetValue) : (obj[key] = targetValue);
                         continue;
                     }
                     const obs = value;
@@ -1243,7 +1276,7 @@ function updateNodes(parent, obj, prevValue) {
                     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;
+                        // It does need to notify itself so isDiff should remain.
                         hasADiff = true;
                     }
                     else if (prevChild !== undefined && prevChild.key !== key) {
@@ -1363,7 +1396,7 @@ const proxyHandler = {
         if (targetNode && p !== 'onChange') {
             return proxyHandler.get(targetNode, p, receiver);
         }
-        if (value instanceof Map || value instanceof WeakMap || value instanceof Set || value instanceof WeakSet) {
+        if (isMap(value) || value instanceof WeakMap || value instanceof Set || value instanceof WeakSet) {
             const ret = handlerMapSet(node, p, value);
             if (ret !== undefined) {
                 return ret;
@@ -1583,13 +1616,22 @@ function assign(node, value) {
     if (isPrimitive(node.root._)) {
         node.root._ = {};
     }
-    // Set inAssign to allow setting on safe observables
-    node.isAssigning = (node.isAssigning || 0) + 1;
-    try {
-        Object.assign(proxy, value);
+    if (isMap(value)) {
+        const currentValue = getNodeValue(node);
+        if (isMap(currentValue)) {
+            value.forEach((value, key) => currentValue.set(key, value));
+        }
     }
-    finally {
-        node.isAssigning--;
+    else {
+        // Set inAssign to allow setting on safe observables
+        node.isAssigning = (node.isAssigning || 0) + 1;
+        try {
+            // TODO: If current value is a Map how to assign into the Map?
+            Object.assign(proxy, value);
+        }
+        finally {
+            node.isAssigning--;
+        }
     }
     endBatch();
     return proxy;
@@ -1631,6 +1673,9 @@ function handlerMapSet(node, p, value) {
                     }
                     return ret;
                 }
+                else if (l === 1 && isMap(value)) {
+                    set(node, a);
+                }
             }
             else if (p === 'delete') {
                 if (l > 0) {
@@ -1763,9 +1808,10 @@ function peek(node) {
 }
 function peekInternal(node, activateRecursive) {
     if (node.dirtyFn) {
-        node.dirtyFn();
-        globalState.dirtyNodes.delete(node);
+        const dirtyFn = node.dirtyFn;
         node.dirtyFn = undefined;
+        globalState.dirtyNodes.delete(node);
+        dirtyFn();
     }
     let value = getNodeValue(node);
     value = checkLazy(node, value, !!activateRecursive);
@@ -1819,6 +1865,7 @@ function activateNodeFunction(node, lazyFn) {
     let update;
     let wasPromise;
     let ignoreThisUpdate;
+    let isFirst = true;
     const activateFn = lazyFn;
     let activatedValue;
     let disposes = [];
@@ -1829,6 +1876,12 @@ function activateNodeFunction(node, lazyFn) {
     }
     node.activatedObserveDispose = observe(() => {
         var _a, _b, _c, _d;
+        // Set it to undefined so that the activation function gets undefined
+        // if it peeks itself
+        if (isFirst) {
+            isFirst = false;
+            setNodeValue(node, undefined);
+        }
         // Run the function at this node
         let value = activateFn();
         // If target is an observable, make this node a link to it
@@ -2102,11 +2155,7 @@ function syncState(obs) {
 }
 
 function computed(get, set) {
-    return observable(set ? () => ({ [symbolLinked]: { get, set: ({ value }) => set(value) } }) : get);
-}
-
-function linked(params) {
-    return (() => ({ [symbolLinked]: params }));
+    return observable(set ? linked({ get: get, set: ({ value }) => set(value) }) : get);
 }
 
 function configureLegendState({ observableFunctions, observableProperties: observableProperties$1, jsonReplacer, jsonReviver, }) {
@@ -2282,7 +2331,9 @@ exports.isBoolean = isBoolean;
 exports.isDate = isDate;
 exports.isEmpty = isEmpty;
 exports.isFunction = isFunction;
+exports.isMap = isMap;
 exports.isNullOrUndefined = isNullOrUndefined;
+exports.isNumber = isNumber;
 exports.isObject = isObject;
 exports.isObservable = isObservable;
 exports.isObservableValueReady = isObservableValueReady;