@legendapp/state 1.0.0-rc.31 → 1.0.0-rc.33

package/index.mjs

@@ -49,155 +49,6 @@ function isChildNodeValue(node) {
     return !!node.parent;
 }
 
-let timeout;
-let numInBatch = 0;
-let isRunningBatch = false;
-let didDelayEndBatch = false;
-let _batch = [];
-let _afterBatch = [];
-// Use a Map of callbacks for fast lookups to update the BatchItem
-let _batchMap = new Map();
-function onActionTimeout() {
-    if (_batch.length > 0) {
-        if (process.env.NODE_ENV === 'development') {
-            console.error('Forcibly completing observableBatcher because end() was never called. This may be due to an uncaught error between begin() and end().');
-        }
-        endBatch(/*force*/ true);
-    }
-}
-function createPreviousHandler(value, changes) {
-    // Create a function that clones the current state and injects the previous data at the changed path
-    return function () {
-        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;
-            }
-        }
-        return clone;
-    };
-}
-function batchNotify(b, immediate) {
-    const isFunc = isFunction(b);
-    const cb = isFunc ? b : b.cb;
-    if (!immediate && numInBatch > 0) {
-        // Set a timeout to call end() in case end() is never called or there's an uncaught error
-        if (!timeout) {
-            timeout = setTimeout(onActionTimeout, 0);
-        }
-        const existing = _batchMap.get(cb);
-        // If this callback already exists, make sure it has the latest value but do not add it
-        if (existing) {
-            if (!isFunc) {
-                const params = existing.params;
-                params.value = b.params.value;
-                params.changes.push(...b.params.changes);
-                params.getPrevious = createPreviousHandler(params.value, params.changes);
-            }
-        }
-        else {
-            if (!isFunc) {
-                b.params.getPrevious = createPreviousHandler(b.params.value, b.params.changes);
-            }
-            _batch.push(b);
-            _batchMap.set(cb, isFunc ? true : b);
-        }
-    }
-    else {
-        // If not batched callback immediately
-        if (isFunc) {
-            b();
-        }
-        else {
-            b.params.getPrevious = createPreviousHandler(b.params.value, b.params.changes);
-            b.cb(b.params);
-        }
-        if (numInBatch === 0) {
-            // Run afterBatch callbacks if this is not batched
-            const after = _afterBatch;
-            _afterBatch = [];
-            for (let i = 0; i < after.length; i++) {
-                after[i]();
-            }
-        }
-    }
-}
-function batch(fn, onComplete) {
-    if (onComplete) {
-        _afterBatch.push(onComplete);
-    }
-    beginBatch();
-    try {
-        fn();
-    }
-    finally {
-        endBatch();
-    }
-}
-function beginBatch() {
-    numInBatch++;
-}
-function endBatch(force) {
-    numInBatch--;
-    if (numInBatch <= 0 || force) {
-        if (isRunningBatch) {
-            // Don't want to run multiple endBatches recursively, so just note that an endBatch
-            // was delayed so that the top level endBatch will run endBatch again after it's done.
-            didDelayEndBatch = true;
-        }
-        else {
-            if (timeout) {
-                clearTimeout(timeout);
-                timeout = undefined;
-            }
-            numInBatch = 0;
-            // Save batch locally and reset _batch first because a new batch could begin while looping over callbacks.
-            // This can happen with observableComputed for example.
-            const batch = _batch;
-            const after = _afterBatch;
-            _batch = [];
-            _batchMap = new Map();
-            _afterBatch = [];
-            isRunningBatch = true;
-            for (let i = 0; i < batch.length; i++) {
-                const b = batch[i];
-                if (isFunction(b)) {
-                    b();
-                }
-                else {
-                    const { cb } = b;
-                    cb(b.params);
-                }
-            }
-            for (let i = 0; i < after.length; i++) {
-                after[i]();
-            }
-            isRunningBatch = false;
-            if (didDelayEndBatch) {
-                didDelayEndBatch = false;
-                endBatch(true);
-            }
-        }
-    }
-}
-function afterBatch(fn) {
-    if (numInBatch > 0) {
-        _afterBatch.push(fn);
-    }
-    else {
-        fn();
-    }
-}
-
 let trackCount = 0;
 const trackingQueue = [];
 const tracking = {
@@ -329,6 +180,206 @@ function findIDKey(obj, node) {
     return idKey;
 }
 
+let timeout;
+let numInBatch = 0;
+let isRunningBatch = false;
+let didDelayEndBatch = false;
+let _afterBatch = [];
+let _batchMap = new Map();
+function onActionTimeout() {
+    if (_batchMap.size > 0) {
+        if (process.env.NODE_ENV === 'development') {
+            console.error('Forcibly completing observableBatcher because end() was never called. This may be due to an uncaught error between begin() and end().');
+        }
+        endBatch(/*force*/ 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]];
+            }
+            o[path[i]] = prevAtPath;
+        }
+        else {
+            clone = prevAtPath;
+        }
+    }
+    return clone;
+}
+function createPreviousHandler(value, changes) {
+    // Create a function that generates the previous state
+    // We don't want to always do this because cloning is expensive
+    // so it's better to run on demand.
+    return function () {
+        return createPreviousHandlerInner(value, changes);
+    };
+}
+function notify(node, value, prev, level, whenOptimizedOnlyIf) {
+    // Run immediate listeners if there are any
+    const changesInBatch = new Map();
+    computeChangesRecursive(changesInBatch, node, value, [], [], value, prev, 
+    /*immediate*/ true, level, whenOptimizedOnlyIf);
+    batchNotifyChanges(changesInBatch, /*immediate*/ true);
+    // Update the current batch
+    const existing = _batchMap.get(node);
+    if (existing) {
+        existing.value = value;
+        // TODO: level, whenOptimizedOnlyIf
+    }
+    else {
+        _batchMap.set(node, { value, prev, level, whenOptimizedOnlyIf });
+    }
+    // If not in a batch run it immediately
+    if (numInBatch <= 0) {
+        runBatch();
+    }
+}
+function computeChangesAtNode(changesInBatch, node, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
+    // If there are listeners at this node compute the changes that need to be run
+    if (immediate ? node.listenersImmediate : node.listeners) {
+        const change = {
+            path,
+            pathTypes,
+            valueAtPath,
+            prevAtPath,
+        };
+        const changeInBatch = changesInBatch.get(node);
+        // If the node itself has been changed then we can ignore all the child changes
+        if (changeInBatch && path.length > 0) {
+            changeInBatch.changes.push(change);
+        }
+        else {
+            changesInBatch.set(node, {
+                level,
+                value,
+                whenOptimizedOnlyIf,
+                changes: [change],
+            });
+        }
+    }
+}
+function computeChangesRecursive(changesInBatch, node, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
+    // Do the compute at this node
+    computeChangesAtNode(changesInBatch, node, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf);
+    // If not root notify up through parents
+    if (node.parent) {
+        const parent = node.parent;
+        if (parent) {
+            const parentValue = getNodeValue(parent);
+            computeChangesRecursive(changesInBatch, parent, parentValue, [node.key].concat(path), [(isArray(value) ? 'array' : 'object')].concat(pathTypes), valueAtPath, prevAtPath, immediate, level + 1, whenOptimizedOnlyIf);
+        }
+    }
+}
+function batchNotifyChanges(changesInBatch, immediate) {
+    // For each change in the batch, notify all of the listeners
+    changesInBatch.forEach(({ changes, level, value, whenOptimizedOnlyIf }, node) => {
+        const listeners = immediate ? node.listenersImmediate : node.listeners;
+        if (listeners) {
+            let listenerParams;
+            // Need to convert to an array here instead of using a for...of loop because listeners can change while iterating
+            const arr = Array.from(listeners);
+            for (let i = 0; i < arr.length; i++) {
+                const listenerFn = arr[i];
+                const { track, noArgs, listener } = listenerFn;
+                const ok = track === true || track === 'shallow'
+                    ? level <= 0
+                    : track === 'optimize'
+                        ? whenOptimizedOnlyIf && level <= 0
+                        : true;
+                // Notify if listener is not shallow or if this is the first level
+                if (ok) {
+                    // Create listenerParams if not already created
+                    if (!noArgs && !listenerParams) {
+                        listenerParams = {
+                            value,
+                            getPrevious: createPreviousHandler(value, changes),
+                            changes,
+                        };
+                    }
+                    listener(listenerParams);
+                }
+            }
+        }
+    });
+}
+function runBatch() {
+    const map = _batchMap;
+    _batchMap = new Map();
+    const changesInBatch = new Map();
+    // First compute all of the changes at each node. It's important to do this first before
+    // running all the notifications because createPreviousHandler depends on knowing
+    // all of the changes happening at the node.
+    map.forEach(({ value, prev, level, whenOptimizedOnlyIf }, node) => {
+        computeChangesRecursive(changesInBatch, node, value, [], [], value, prev, false, level, whenOptimizedOnlyIf);
+    });
+    // Once all changes are computed, notify all listeners for each node with the computed changes.
+    batchNotifyChanges(changesInBatch, false);
+}
+function batch(fn, onComplete) {
+    if (onComplete) {
+        _afterBatch.push(onComplete);
+    }
+    beginBatch();
+    try {
+        fn();
+    }
+    finally {
+        endBatch();
+    }
+}
+function beginBatch() {
+    numInBatch++;
+    if (!timeout) {
+        timeout = setTimeout(onActionTimeout, 0);
+    }
+}
+function endBatch(force) {
+    numInBatch--;
+    if (numInBatch <= 0 || force) {
+        if (isRunningBatch) {
+            // Don't want to run multiple endBatches recursively, so just note that an endBatch
+            // was delayed so that the top level endBatch will run endBatch again after it's done.
+            didDelayEndBatch = true;
+        }
+        else {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            numInBatch = 0;
+            // Save batch locally and reset _batch first because a new batch could begin while looping over callbacks.
+            // This can happen with observableComputed for example.
+            const after = _afterBatch;
+            _afterBatch = [];
+            isRunningBatch = true;
+            runBatch();
+            isRunningBatch = false;
+            if (didDelayEndBatch) {
+                didDelayEndBatch = false;
+                endBatch(true);
+            }
+            for (let i = 0; i < after.length; i++) {
+                after[i]();
+            }
+        }
+    }
+}
+function afterBatch(fn) {
+    if (numInBatch > 0) {
+        _afterBatch.push(fn);
+    }
+    else {
+        fn();
+    }
+}
+
 function isObservable(obs) {
     return obs && !!obs[symbolIsObservable];
 }
@@ -478,69 +529,23 @@ function isObservableValueReady(value) {
     return !!value && ((!isObject(value) && !isArray(value)) || !isEmpty(value));
 }
 
-function doNotify(node, value, path, pathTypes, valueAtPath, prevAtPath, level, whenOptimizedOnlyIf) {
-    const listeners = node.listeners;
-    if (listeners) {
-        let listenerParams;
-        // Need to convert to an array here instead of using a for...of loop because listeners can change while iterating
-        const arr = Array.from(listeners);
-        for (let i = 0; i < arr.length; i++) {
-            const listenerFn = arr[i];
-            const { track, noArgs, immediate, listener } = listenerFn;
-            const ok = track === true || track === 'shallow'
-                ? level <= 0
-                : track === 'optimize'
-                    ? whenOptimizedOnlyIf && level <= 0
-                    : true;
-            // Notify if listener is not shallow or if this is the first level
-            if (ok) {
-                if (!noArgs && !listenerParams) {
-                    listenerParams = {
-                        value,
-                        changes: [
-                            {
-                                path,
-                                pathTypes,
-                                valueAtPath,
-                                prevAtPath,
-                            },
-                        ],
-                    };
-                }
-                batchNotify(noArgs ? listener : { cb: listener, params: listenerParams }, immediate);
-            }
+function onChange(node, callback, options) {
+    const { trackingType, initial, immediate, noArgs } = options || {};
+    let listeners = immediate ? node.listenersImmediate : node.listeners;
+    if (!listeners) {
+        listeners = new Set();
+        if (immediate) {
+            node.listenersImmediate = listeners;
         }
-    }
-}
-function _notifyParents(node, value, path, pathTypes, valueAtPath, prevAtPath, level, whenOptimizedOnlyIf) {
-    // Do the notify
-    doNotify(node, value, path, pathTypes, valueAtPath, prevAtPath, level, whenOptimizedOnlyIf);
-    // If not root notify up through parents
-    if (node.parent) {
-        const parent = node.parent;
-        if (parent) {
-            const parentValue = getNodeValue(parent);
-            _notifyParents(parent, parentValue, [node.key].concat(path), [(isArray(value) ? 'array' : 'object')].concat(pathTypes), valueAtPath, prevAtPath, level + 1, whenOptimizedOnlyIf);
+        else {
+            node.listeners = listeners;
         }
     }
-}
-function notify(node, value, prev, level, whenOptimizedOnlyIf) {
-    // Notify self and up through parents
-    _notifyParents(node, value, [], [], value, prev, level, whenOptimizedOnlyIf);
-}
-
-function onChange(node, callback, options, noArgs) {
-    let listeners = node.listeners;
-    if (!listeners) {
-        node.listeners = listeners = new Set();
-    }
     checkActivate(node);
-    const { trackingType, initial, immediate } = options || {};
     const listener = {
         listener: callback,
         track: trackingType,
         noArgs,
-        immediate: immediate,
     };
     listeners.add(listener);
     let parent = node.parent;
@@ -608,7 +613,7 @@ ObservablePrimitiveClass.prototype.set = function (value) {
     const root = this._node.root;
     const prev = root._;
     root._ = value;
-    doNotify(this._node, value, [], [], value, prev, 0);
+    notify(this._node, value, prev, 0);
     return this;
 };
 ObservablePrimitiveClass.prototype.toggle = function () {
@@ -621,9 +626,13 @@ ObservablePrimitiveClass.prototype.toggle = function () {
     }
     return !value;
 };
+ObservablePrimitiveClass.prototype.delete = function () {
+    this.set(undefined);
+    return this;
+};
 // Listener
-ObservablePrimitiveClass.prototype.onChange = function (cb, options, noArgs) {
-    return onChange(this._node, cb, options, noArgs);
+ObservablePrimitiveClass.prototype.onChange = function (cb, options) {
+    return onChange(this._node, cb, options);
 };
 
 let inSet = false;
@@ -683,8 +692,8 @@ function updateNodes(parent, obj, prevValue) {
     if ((isObject(obj) && obj[symbolOpaque]) || (isObject(prevValue) && prevValue[symbolOpaque])) {
         const isDiff = obj !== prevValue;
         if (isDiff) {
-            if (parent.listeners) {
-                doNotify(parent, obj, [], [], obj, prevValue, 0);
+            if (parent.listeners || parent.listenersImmediate) {
+                notify(parent, obj, prevValue, 0);
             }
         }
         return isDiff;
@@ -701,7 +710,7 @@ function updateNodes(parent, obj, prevValue) {
         // Construct a map of previous indices for computing move
         if (prevValue.length > 0) {
             const firstPrevValue = prevValue[0];
-            if (firstPrevValue) {
+            if (firstPrevValue !== undefined) {
                 idField = findIDKey(firstPrevValue, parent);
                 if (idField) {
                     isIdFieldFunction = isFunction(idField);
@@ -745,8 +754,8 @@ function updateNodes(parent, obj, prevValue) {
                     if (!isPrimitive(prev)) {
                         updateNodes(child, undefined, prev);
                     }
-                    if (child.listeners) {
-                        doNotify(child, undefined, [], [], undefined, prev, 0);
+                    if (child.listeners || child.listenersImmediate) {
+                        notify(child, undefined, prev, 0);
                     }
                 }
             }
@@ -781,6 +790,7 @@ function updateNodes(parent, obj, prevValue) {
                             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.
@@ -792,8 +802,7 @@ function updateNodes(parent, obj, prevValue) {
                             }
                             didMove = true;
                             // And check for diff against the previous value in the previous position
-                            const prevOfNode = prevChild;
-                            isDiff = prevOfNode !== value;
+                            isDiff = valuePrevChild !== value;
                         }
                     }
                     if (isDiff) {
@@ -813,8 +822,8 @@ function updateNodes(parent, obj, prevValue) {
                         // 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) {
-                            doNotify(child, value, [], [], value, prev, 0, !isArrDiff);
+                        if (child.listeners || child.listenersImmediate) {
+                            notify(child, value, prev, 0, !isArrDiff);
                         }
                     }
                 }
@@ -1119,7 +1128,7 @@ function setupTracking(nodes, update, noArgs, immediate) {
     // Listen to tracked nodes
     nodes === null || nodes === void 0 ? void 0 : nodes.forEach((tracked) => {
         const { node, track } = tracked;
-        listeners.push(onChange(node, update, { trackingType: track, immediate }, noArgs));
+        listeners.push(onChange(node, update, { trackingType: track, immediate, noArgs }));
     });
     return () => {
         if (listeners) {
@@ -1181,10 +1190,12 @@ function observe(selectorOrRun, reactionOrOptions, options) {
             e.onCleanupReaction();
             e.onCleanupReaction = undefined;
         }
-        if (reaction && (e.num > 0 || !selectorOrRun[symbolIsEvent]) && e.previous !== e.value) {
+        // Call the reaction if there is one and the value changed
+        if (reaction && (e.num > 0 || !(selectorOrRun === null || selectorOrRun === void 0 ? void 0 : selectorOrRun[symbolIsEvent])) && e.previous !== e.value) {
             reaction(e);
-            e.previous = e.value;
         }
+        // Update the previous value
+        e.previous = e.value;
         // Increment the counter
         e.num++;
         endBatch();
@@ -1252,12 +1263,12 @@ function event() {
     };
 }
 
-function when(predicate, effect) {
+function _when(predicate, effect, checkReady) {
     let value;
     // Create a wrapping fn that calls the effect if predicate returns true
     function run(e) {
         const ret = computeSelector(predicate);
-        if (isObservableValueReady(ret)) {
+        if (checkReady ? isObservableValueReady(ret) : ret) {
             value = ret;
             // If value is truthy then run the effect
             effect === null || effect === void 0 ? void 0 : effect(ret);
@@ -1265,14 +1276,15 @@ function when(predicate, effect) {
             e.cancel = true;
         }
     }
-    // Create an effect for the fn
+    // Run in an observe
     observe(run);
-    // If first run resulted in a truthy value just return it
+    // If first run resulted in a truthy value just return it.
     // It will have set e.cancel so no need to dispose
     if (value !== undefined) {
         return Promise.resolve(value);
     }
     else {
+        // Wrap it in a promise
         const promise = new Promise((resolve) => {
             if (effect) {
                 const originalEffect = effect;
@@ -1288,6 +1300,12 @@ function when(predicate, effect) {
         return promise;
     }
 }
+function when(predicate, effect) {
+    return _when(predicate, effect, false);
+}
+function whenReady(predicate, effect) {
+    return _when(predicate, effect, true);
+}
 
 const internal = {
     getNode,
@@ -1296,5 +1314,5 @@ const internal = {
     symbolDelete
 };
 
-export { ObservablePrimitiveClass, afterBatch, batch, beginBatch, beginTracking, checkActivate, computeSelector, computed, constructObjectWithPath, deconstructObjectWithPath, endBatch, endTracking, event, extraPrimitiveActivators, extraPrimitiveProps, findIDKey, getNode, getNodeValue, getObservableIndex, internal, isArray, isBoolean, isEmpty, isFunction, isObject, isObservable, isObservableValueReady, isPrimitive, isPromise, isString, isSymbol, lockObservable, mergeIntoObservable, observable, observablePrimitive, observe, opaqueObject, setAtPath, setInObservableAtPath, setupTracking, symbolDelete, symbolIsEvent, symbolIsObservable, tracking, updateTracking, when };
+export { ObservablePrimitiveClass, afterBatch, batch, beginBatch, beginTracking, checkActivate, computeSelector, computed, constructObjectWithPath, deconstructObjectWithPath, endBatch, endTracking, event, extraPrimitiveActivators, extraPrimitiveProps, findIDKey, getNode, getNodeValue, getObservableIndex, internal, isArray, isBoolean, isEmpty, isFunction, isObject, isObservable, isObservableValueReady, isPrimitive, isPromise, isString, isSymbol, lockObservable, mergeIntoObservable, observable, observablePrimitive, observe, opaqueObject, setAtPath, setInObservableAtPath, setupTracking, symbolDelete, symbolIsEvent, symbolIsObservable, tracking, updateTracking, when, whenReady };
 //# sourceMappingURL=index.mjs.map