@legendapp/state 0.16.1 → 0.17.0-next.0

package/index.d.ts

@@ -9,3 +9,4 @@ export { when } from './src/when';
 export * from './src/observableInterfaces';
 export { isEmpty } from './src/is';
 export { lockObservable } from './src/helpers';
+export { ObservablePrimitive } from './src/ObservablePrimitive';

package/index.js

@@ -7,6 +7,7 @@ const tracking = {
     nodes: undefined,
     listeners: undefined,
     updates: undefined,
+    callbacksMarked: new Set(),
 };
 function beginTracking() {
     // Keep a copy of the previous tracking context so it can be restored
@@ -59,6 +60,22 @@ function checkTracking(node, track) {
         }
     }
 }
+let timeoutSweep;
+function scheduleSweep() {
+    if (timeoutSweep) {
+        clearTimeout(timeoutSweep);
+    }
+    timeoutSweep = setTimeout(sweep, 0);
+}
+function sweep() {
+    timeoutSweep = undefined;
+    if (tracking.callbacksMarked.size)
+        console.log('sweeping');
+    for (let marked of tracking.callbacksMarked) {
+        marked();
+    }
+    tracking.callbacksMarked.clear();
+}
 
 /** @internal */
 function isArray(obj) {
@@ -92,6 +109,15 @@ function isBoolean(obj) {
 function isEmpty(obj) {
     return obj && Object.keys(obj).length === 0;
 }
+const mapPrimitives = new Map([
+    ['boolean', true],
+    ['string', true],
+    ['number', true],
+]);
+/** @internal */
+function isActualPrimitive(arg) {
+    return mapPrimitives.has(typeof arg);
+}
 
 const symbolDateModified = Symbol('dateModified');
 const symbolIsObservable = Symbol('isObservable');
@@ -160,48 +186,32 @@ function getChildNode(node, key) {
     return child;
 }
 
-function isObservable(obs) {
-    return obs && !!obs[symbolIsObservable];
-}
-function getNode(obs) {
-    return obs[symbolGetNode];
-}
-function lockObservable(obs, value) {
-    var _a;
-    const root = (_a = getNode(obs)) === null || _a === void 0 ? void 0 : _a.root;
-    if (root) {
-        root.locked = value;
-    }
-}
-function mergeIntoObservable(target, ...sources) {
-    var _a, _b;
-    if (!sources.length)
-        return target;
-    const source = sources.shift();
-    const needsSet = isObservable(target);
-    if (isObject(target) && isObject(source)) {
-        if (source[symbolDateModified]) {
-            if (needsSet) {
-                target.set(symbolDateModified, source[symbolDateModified]);
-            }
-            else {
-                target[symbolDateModified] = source[symbolDateModified];
-            }
-        }
-        const value = ((_b = (_a = target).get) === null || _b === void 0 ? void 0 : _b.call(_a)) || target;
-        for (const key in source) {
-            if (isObject(source[key])) {
-                if (!value[key] || !isObject(value[key])) {
-                    needsSet ? target.set(key, {}) : (target[key] = {});
-                }
-                mergeIntoObservable(target[key], source[key]);
-            }
-            else {
-                needsSet ? target.set(key, source[key]) : (target[key] = source[key]);
-            }
-        }
-    }
-    return mergeIntoObservable(target, ...sources);
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 }
 
 let timeout;
@@ -269,14 +279,185 @@ function endBatch(force) {
     }
 }
 
-function onChange(node, callback, track, noArgs) {
+function createPreviousHandler(value, path, prevAtPath) {
+    // 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)) : path.length > 0 ? {} : value;
+        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 doNotify(node, value, path, valueAtPath, prevAtPath, level, whenOptimizedOnlyIf) {
+    const listeners = node.listeners;
+    if (listeners) {
+        let getPrevious;
+        for (let listenerFn of listeners) {
+            const { track, noArgs } = listenerFn;
+            const ok = track === exports.Tracking.shallow
+                ? level <= 0
+                : track === exports.Tracking.optimized
+                    ? whenOptimizedOnlyIf && level <= 0
+                    : true;
+            // Notify if listener is not shallow or if this is the first level
+            if (ok) {
+                // Create a function to get the previous data. Computing a clone of previous data can be expensive if doing
+                // it often, so leave it up to the caller.
+                if (!noArgs && !getPrevious) {
+                    getPrevious = createPreviousHandler(value, path, prevAtPath);
+                }
+                batchNotify(noArgs
+                    ? listenerFn.listener
+                    : {
+                        cb: listenerFn.listener,
+                        value,
+                        getPrevious,
+                        path,
+                        valueAtPath,
+                        prevAtPath,
+                        node,
+                    });
+            }
+        }
+    }
+}
+function _notifyParents(node, value, path, valueAtPath, prevAtPath, level, whenOptimizedOnlyIf) {
+    // Do the notify
+    doNotify(node, value, path, 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), valueAtPath, prevAtPath, level + 1, whenOptimizedOnlyIf);
+        }
+    }
+}
+function notify(node, value, prev, level, whenOptimizedOnlyIf) {
+    // Notify self and up through parents
+    _notifyParents(node, value, [], value, prev, level, whenOptimizedOnlyIf);
+}
+
+function onChange(node, callback, track, noArgs, markAndSweep) {
     let listeners = node.listeners;
     if (!listeners) {
         node.listeners = listeners = new Set();
     }
-    const listener = { listener: callback, track: track, noArgs };
+    let dispose;
+    let listener;
+    let c = callback;
+    if (markAndSweep) {
+        c = function () {
+            tracking.callbacksMarked.add(dispose);
+            callback();
+        };
+    }
+    listener = { listener: c, track: track, noArgs };
     listeners.add(listener);
-    return () => listeners.delete(listener);
+    return (dispose = () => {
+        if (markAndSweep) {
+            tracking.callbacksMarked.delete(dispose);
+        }
+        listeners.delete(listener);
+    });
+}
+
+var _ObservablePrimitive_node;
+class ObservablePrimitive {
+    constructor(node) {
+        _ObservablePrimitive_node.set(this, void 0);
+        __classPrivateFieldSet(this, _ObservablePrimitive_node, node, "f");
+        this.set = this.set.bind(this);
+    }
+    get value() {
+        const node = __classPrivateFieldGet(this, _ObservablePrimitive_node, "f");
+        updateTracking(node);
+        return node.root._;
+    }
+    set value(value) {
+        if (__classPrivateFieldGet(this, _ObservablePrimitive_node, "f").root.locked) {
+            throw new Error(process.env.NODE_ENV === 'development'
+                ? '[legend-state] Cannot modify an observable while it is locked. Please make sure that you unlock the observable before making changes.'
+                : '[legend-state] Modified locked observable');
+        }
+        const prev = __classPrivateFieldGet(this, _ObservablePrimitive_node, "f").root._;
+        __classPrivateFieldGet(this, _ObservablePrimitive_node, "f").root._ = value;
+        doNotify(__classPrivateFieldGet(this, _ObservablePrimitive_node, "f"), value, [], value, prev, 0);
+    }
+    get() {
+        return this.value;
+    }
+    set(value) {
+        if (isFunction(value)) {
+            value = value(__classPrivateFieldGet(this, _ObservablePrimitive_node, "f").root._);
+        }
+        this.value = value;
+        return this;
+    }
+    onChange(cb, track, noArgs, markAndSweep) {
+        return onChange(__classPrivateFieldGet(this, _ObservablePrimitive_node, "f"), cb, track, noArgs, markAndSweep);
+    }
+    obs() {
+        return this;
+    }
+    /** @internal */
+    getNode() {
+        return __classPrivateFieldGet(this, _ObservablePrimitive_node, "f");
+    }
+}
+_ObservablePrimitive_node = new WeakMap();
+
+function isObservable(obs) {
+    return obs && (obs instanceof ObservablePrimitive || !!obs[symbolIsObservable]);
+}
+function getNode(obs) {
+    return obs instanceof ObservablePrimitive ? obs.getNode() : obs[symbolGetNode];
+}
+function lockObservable(obs, value) {
+    var _a;
+    const root = (_a = getNode(obs)) === null || _a === void 0 ? void 0 : _a.root;
+    if (root) {
+        root.locked = value;
+    }
+}
+function mergeIntoObservable(target, ...sources) {
+    var _a, _b;
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    const needsSet = isObservable(target);
+    if (isObject(target) && isObject(source)) {
+        if (source[symbolDateModified]) {
+            if (needsSet) {
+                target.set(symbolDateModified, source[symbolDateModified]);
+            }
+            else {
+                target[symbolDateModified] = source[symbolDateModified];
+            }
+        }
+        const value = ((_b = (_a = target).get) === null || _b === void 0 ? void 0 : _b.call(_a)) || target;
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!value[key] || !isObject(value[key])) {
+                    needsSet ? target.set(key, {}) : (target[key] = {});
+                }
+                mergeIntoObservable(target[key], source[key]);
+            }
+            else {
+                needsSet ? target.set(key, source[key]) : (target[key] = source[key]);
+            }
+        }
+    }
+    return mergeIntoObservable(target, ...sources);
 }
 
 let lastAccessedNode;
@@ -305,21 +486,22 @@ const objectFns = new Map([
     ['delete', deleteFn],
 ]);
 // Override primitives
-const wrapFn = (fn) => function (...args) {
+const wrapFn = (name, fn) => function (...args) {
     if (lastAccessedNode && lastAccessedPrimitive) {
         const node = getChildNode(lastAccessedNode, lastAccessedPrimitive);
         if (getNodeValue(node) === this) {
             return fn(node, ...args);
         }
         else if (process.env.NODE_ENV === 'development') {
-            console.error(`[legend-state] Error calling ${fn} on a primitive with value ${this}. Please ensure that if you are saving references to observable functions on primitive values that you use obs() first, like obs.primitive.obs().set.`);
+            console.error(`[legend-state] Error calling ${name} on a primitive with value [${this}]. Please ensure that if you are saving references to observable functions on primitive values that you use obs() first, like obs.primitive.obs().set.`);
+            debugger;
         }
     }
 };
 const toOverride = [Number, Boolean, String];
 for (let [key, fn] of objectFns) {
     for (let i = 0; i < toOverride.length; i++) {
-        toOverride[i].prototype[key] = wrapFn(fn);
+        toOverride[i].prototype[key] = wrapFn(key, fn);
     }
 }
 function collectionSetter(node, target, prop, ...args) {
@@ -377,7 +559,7 @@ function updateNodes(parent, obj, prevValue) {
                     updateNodes(child, undefined, prev);
                 }
                 if (child.listeners) {
-                    _notify(child, undefined, [], undefined, prev, 0);
+                    doNotify(child, undefined, [], undefined, prev, 0);
                 }
             }
         }
@@ -431,7 +613,7 @@ function updateNodes(parent, obj, prevValue) {
                     // But do not notify child if the parent is an array with changing length -
                     // the array's listener will cover it
                     if (child.listeners) {
-                        _notify(child, value, [], value, prev, 0, !isArrDiff);
+                        doNotify(child, value, [], value, prev, 0, !isArrDiff);
                     }
                 }
             }
@@ -491,7 +673,7 @@ const proxyHandler = {
             };
         }
         let value = getNodeValue(node);
-        if (!node.parent && isPrimitive(value) && p === 'value') {
+        if (!node.parent && isPrimitive(value) && node.root._ === value && p === 'value') {
             updateTracking(node);
             return value;
         }
@@ -686,73 +868,6 @@ function setProp(node, key, newValue, level) {
     inSetFn = false;
     return isRoot ? getProxy(node) : getProxy(node, key);
 }
-function createPreviousHandler(value, path, prevAtPath) {
-    // 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)) : path.length > 0 ? {} : value;
-        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 _notify(node, value, path, valueAtPath, prevAtPath, level, whenOptimizedOnlyIf) {
-    const listeners = node.listeners;
-    if (listeners) {
-        let getPrevious;
-        for (let listenerFn of listeners) {
-            const { track, noArgs } = listenerFn;
-            const ok = track === exports.Tracking.shallow
-                ? level <= 0
-                : track === exports.Tracking.optimized
-                    ? whenOptimizedOnlyIf && level <= 0
-                    : true;
-            // Notify if listener is not shallow or if this is the first level
-            if (ok) {
-                // Create a function to get the previous data. Computing a clone of previous data can be expensive if doing
-                // it often, so leave it up to the caller.
-                if (!getPrevious) {
-                    getPrevious = createPreviousHandler(value, path, prevAtPath);
-                }
-                batchNotify(noArgs
-                    ? listenerFn.listener
-                    : {
-                        cb: listenerFn.listener,
-                        value,
-                        getPrevious,
-                        path,
-                        valueAtPath,
-                        prevAtPath,
-                        node,
-                    });
-            }
-        }
-    }
-}
-function _notifyParents(node, value, path, valueAtPath, prevAtPath, level, whenOptimizedOnlyIf) {
-    // Do the notify
-    _notify(node, value, path, 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), valueAtPath, prevAtPath, level + 1, whenOptimizedOnlyIf);
-        }
-    }
-}
-function notify(node, value, prev, level, whenOptimizedOnlyIf) {
-    // Notify self and up through parents
-    _notifyParents(node, value, [], value, prev, level, whenOptimizedOnlyIf);
-}
 function assign(node, value) {
     const proxy = getProxy(node);
     beginBatch();
@@ -788,25 +903,31 @@ function observable(value, safe) {
         id: nextNodeID.current++,
         root: obs,
     };
-    const proxy = getProxy(node);
-    if (promise) {
-        promise.catch((error) => {
-            proxy.set({ error });
-        });
-        promise.then((value) => {
-            proxy.set(value);
-        });
+    if (isActualPrimitive(value)) {
+        // @ts-ignore
+        return new ObservablePrimitive(node);
+    }
+    else {
+        const proxy = getProxy(node);
+        if (promise) {
+            promise.catch((error) => {
+                proxy.set({ error });
+            });
+            promise.then((value) => {
+                proxy.set(value);
+            });
+        }
+        return proxy;
     }
-    return proxy;
 }
 
-function setupTracking(nodes, update, noArgs) {
+function setupTracking(nodes, update, noArgs, markAndSweep) {
     let listeners = [];
     // Listen to tracked nodes
     if (nodes) {
         for (let tracked of nodes.values()) {
             const { node, track } = tracked;
-            listeners.push(onChange(node, update, track, noArgs));
+            listeners.push(onChange(node, update, track, noArgs, markAndSweep));
         }
     }
     return () => {
@@ -824,7 +945,7 @@ function observe(run) {
     // Wrap it in a function so it doesn't pass all the arguments to run()
     let update = function () {
         var _a;
-        if (cleanup) {
+        if (cleanup && isFunction(cleanup)) {
             cleanup();
             cleanup = undefined;
         }
@@ -849,7 +970,7 @@ function observe(run) {
             update = tracking.updates(update);
         }
     }
-    const ret = setupTracking(tracking.nodes, update);
+    const ret = setupTracking(tracking.nodes, update, /*noArgs*/ true);
     endTracking(trackingPrev);
     return ret;
 }
@@ -861,11 +982,14 @@ function computed(compute) {
         const val = compute();
         if (obs) {
             // Update the computed value
+            lockObservable(obs, false);
             obs.set(val);
+            lockObservable(obs, true);
         }
         else {
             // Create the observable on the first run
             obs = observable(val);
+            lockObservable(obs, true);
         }
     };
     observe(fn);
@@ -881,8 +1005,10 @@ function event() {
             // Notify increments the value so that the observable changes
             obs.value++;
         },
-        on: obs.onChange,
-        get: obs.get,
+        on: function (cb) {
+            return obs.onChange(cb);
+        },
+        get: () => obs.get(),
     };
 }
 
@@ -913,6 +1039,7 @@ function when(predicate, effect) {
     return promise || cleanup;
 }
 
+exports.ObservablePrimitive = ObservablePrimitive;
 exports.batch = batch;
 exports.beginBatch = beginBatch;
 exports.beginTracking = beginTracking;
@@ -934,7 +1061,9 @@ exports.mergeIntoObservable = mergeIntoObservable;
 exports.observable = observable;
 exports.observe = observe;
 exports.onChange = onChange;
+exports.scheduleSweep = scheduleSweep;
 exports.setupTracking = setupTracking;
+exports.sweep = sweep;
 exports.symbolDateModified = symbolDateModified;
 exports.symbolIsObservable = symbolIsObservable;
 exports.symbolUndef = symbolUndef;