@legendapp/state 0.15.0-next.8 → 0.15.1

package/index.mjs

@@ -36,10 +36,7 @@ const tracking = {
     listeners: undefined,
     updates: undefined,
 };
-function updateTracking(node, parent, track, manual) {
-    if (parent) {
-        untrack(parent);
-    }
+function updateTracking(node, track, manual) {
     const existing = tracking.nodes.get(node.id);
     if (existing) {
         existing.track = existing.track || track;
@@ -64,6 +61,9 @@ function untrack(node) {
 
 const symbolDateModified = Symbol('dateModified');
 const symbolIsObservable = Symbol('isObservable');
+const symbolGetNode = Symbol('getNode');
+const symbolUndef = Symbol('undef');
+const extraPrimitiveProps = new Map();
 var Tracking;
 (function (Tracking) {
     Tracking.normal = true;
@@ -74,7 +74,7 @@ const nextNodeID = { current: 0 };
 function checkTracking(node, track) {
     if (tracking.nodes) {
         if (track) {
-            updateTracking(node, undefined, track, /*manual*/ true);
+            updateTracking(node, track, /*manual*/ true);
         }
         else {
             untrack(node);
@@ -86,10 +86,13 @@ function get(node, keyOrTrack, track) {
         track = keyOrTrack;
         keyOrTrack = undefined;
     }
+    if (keyOrTrack) {
+        node = getChildNode(node, keyOrTrack);
+    }
     // Track by default
     checkTracking(node, track === true || track === undefined ? Tracking.normal : track === false ? undefined : track);
-    const value = getOutputValue(node);
-    return keyOrTrack ? value === null || value === void 0 ? void 0 : value[keyOrTrack] : value;
+    const value = getNodeValue(node);
+    return node.root.isPrimitive ? value.value : value;
 }
 function getNodeValue(node) {
     const arr = [];
@@ -106,13 +109,6 @@ function getNodeValue(node) {
     }
     return child;
 }
-function getOutputValue(node) {
-    let value = getNodeValue(node);
-    if (node.root.isPrimitive) {
-        value = value.value;
-    }
-    return value;
-}
 function getChildNode(node, key) {
     var _a;
     if (isString(key)) {
@@ -143,6 +139,16 @@ function getChildNode(node, key) {
 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)
@@ -230,33 +236,20 @@ function endBatch(force) {
     }
 }
 
-let listenerIndex = 0;
-function onChange(node, callback, options) {
-    let id = listenerIndex++;
+function onChange(node, callback, track) {
     let listeners = node.listeners;
     if (!listeners) {
-        node.listeners = listeners = new Map();
+        node.listeners = listeners = new Set();
     }
-    if (options) {
-        // A memory efficient way to save shallowness is to put it on the id itself
-        if (options.shallow)
-            id = 's' + id;
-        else if (options.optimized)
-            id = 'o' + id;
-        if (options.runImmediately) {
-            const value = getNodeValue(node);
-            callback(value, () => value, [], value, value, node);
-        }
-    }
-    listeners.set(id, callback);
-    return () => listeners.delete(id);
+    const listener = { listener: callback, track: track };
+    listeners.add(listener);
+    return () => listeners.delete(listener);
 }
 
 let lastAccessedNode;
 let lastAccessedPrimitive;
 let inSetFn = false;
 let inAssign = false;
-const undef = Symbol('undef');
 const ArrayModifiers = new Set([
     'copyWithin',
     'fill',
@@ -273,7 +266,7 @@ const ArrayLoopers = new Set(['every', 'some', 'filter', 'forEach', 'map']);
 const objectFns = new Map([
     ['get', get],
     ['set', set],
-    ['ref', ref],
+    ['obs', obs],
     ['onChange', onChange],
     ['assign', assign],
     ['delete', deleteFn],
@@ -286,28 +279,27 @@ const wrapFn = (fn) => function (...args) {
             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 ref() first, like obs.primitive.ref().set.`);
+            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.`);
         }
     }
 };
 const toOverride = [Number, Boolean, String];
-objectFns.forEach((fn, key) => {
+for (let [key, fn] of objectFns) {
     for (let i = 0; i < toOverride.length; i++) {
         toOverride[i].prototype[key] = wrapFn(fn);
     }
-});
+}
 function collectionSetter(node, target, prop, ...args) {
     const prevValue = (isArray(target) && target.slice()) || target;
     const ret = target[prop].apply(target, args);
     if (node) {
         const parent = node.parent;
-        if (parent) {
-            const parentValue = getNodeValue(parent);
-            // Set the object to the previous value first
-            parentValue[node.key] = prevValue;
-            // Then set with the new value so it notifies with the correct prevValue
-            setProp(parent, node.key, target);
-        }
+        const key = parent ? node.key : '_';
+        const parentValue = parent ? getNodeValue(parent) : node.root;
+        // Set the object to the previous value first
+        parentValue[key] = prevValue;
+        // Then set with the new value so it notifies with the correct prevValue
+        setProp(parent || node, parent ? key : symbolUndef, target);
     }
     // Return the original value
     return ret;
@@ -322,14 +314,6 @@ function updateNodes(parent, obj, prevValue) {
     if (isArr && isArray(prevValue)) {
         // Construct a map of previous indices for computing move
         if ((prevValue === null || prevValue === void 0 ? void 0 : prevValue.length) > 0) {
-            if (parent.listeners) {
-                for (let listenerFn of parent.listeners) {
-                    // if listener is not optimized
-                    if (listenerFn[0][0] === 'o') {
-                        break;
-                    }
-                }
-            }
             const p = prevValue[0];
             if (p) {
                 idField =
@@ -359,8 +343,7 @@ function updateNodes(parent, obj, prevValue) {
                 if (!isPrimitive(prev)) {
                     updateNodes(child, undefined, prev);
                 }
-                const doNotify = !!child.listeners;
-                if (doNotify) {
+                if (child.listeners) {
                     _notify(child, undefined, [], undefined, prev, 0);
                 }
             }
@@ -414,8 +397,7 @@ 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
-                    const doNotify = !!child.listeners;
-                    if (doNotify) {
+                    if (child.listeners) {
                         _notify(child, value, [], value, prev, 0, !isArrDiff);
                     }
                 }
@@ -427,7 +409,6 @@ function updateNodes(parent, obj, prevValue) {
                 parent.children.set(key, child);
             }
         }
-        // TODO: !isArrDiff should only be for optimized listeners
         // The full array does not need to re-render if the length is the same
         // So don't notify shallow listeners
         return hasADiff || didMove;
@@ -438,13 +419,9 @@ function getProxy(node, p) {
     if (p !== undefined)
         node = getChildNode(node, p);
     // Create a proxy if not already cached and return it
-    let proxy = node.proxy;
-    if (!proxy) {
-        proxy = node.proxy = new Proxy(node, proxyHandler);
-    }
-    return proxy;
+    return node.proxy || (node.proxy = new Proxy(node, proxyHandler));
 }
-function ref(node, keyOrTrack, track) {
+function obs(node, keyOrTrack, track) {
     if (isBoolean(keyOrTrack) || isSymbol(keyOrTrack)) {
         track = keyOrTrack;
         keyOrTrack = undefined;
@@ -452,25 +429,27 @@ function ref(node, keyOrTrack, track) {
     if (keyOrTrack !== undefined) {
         node = getChildNode(node, keyOrTrack);
     }
-    // Untrack by default
-    checkTracking(node, track === true ? Tracking.normal : track === false ? undefined : track);
+    // Don't untrack if getting node by key
+    if (track !== undefined || !keyOrTrack) {
+        // Untrack by default
+        checkTracking(node, track === true ? Tracking.normal : track === false ? undefined : track);
+    }
     return getProxy(node);
 }
 const proxyHandler = {
     get(target, p) {
+        var _a, _b;
         // Return true is called by isObservable()
         if (p === symbolIsObservable) {
             return true;
         }
+        if (p === symbolGetNode) {
+            return target;
+        }
         const node = target;
         const fn = objectFns.get(p);
         // If this is an observable function, call it
         if (fn) {
-            if (p !== 'get' && p !== 'ref') {
-                // Observable operations do not create listeners
-                if (tracking.nodes)
-                    untrack(node);
-            }
             return function (a, b, c) {
                 const l = arguments.length;
                 // Array call and apply are slow so micro-optimize this hot path.
@@ -496,7 +475,7 @@ const proxyHandler = {
                     // Update that this node was accessed for observers
                     // Listen to the array shallowly
                     if (tracking.nodes) {
-                        updateTracking(node, undefined, Tracking.shallow);
+                        updateTracking(node, Tracking.shallow);
                     }
                     return function (cbOrig, thisArg) {
                         function cb(_, index, array) {
@@ -511,6 +490,12 @@ const proxyHandler = {
         }
         // Accessing primitive returns the raw value
         if (vProp === undefined || vProp === null || isPrimitive(vProp)) {
+            if (extraPrimitiveProps.size) {
+                const vPrim = extraPrimitiveProps.get(p);
+                if (vPrim !== undefined) {
+                    return (_b = (_a = vPrim === null || vPrim === void 0 ? void 0 : vPrim.__fn) === null || _a === void 0 ? void 0 : _a.call(vPrim, target)) !== null && _b !== void 0 ? _b : vPrim;
+                }
+            }
             // Accessing a primitive saves the last accessed so that the observable functions
             // bound to primitives can know which node was accessed
             lastAccessedNode = node;
@@ -518,13 +503,13 @@ const proxyHandler = {
             // Update that this primitive node was accessed for observers
             if (tracking.nodes) {
                 if (isArray(value) && p === 'length') {
-                    updateTracking(node, undefined, Tracking.shallow);
+                    updateTracking(node, Tracking.shallow);
                 }
                 else if (node.root.isPrimitive) {
                     updateTracking(node);
                 }
-                else {
-                    updateTracking(getChildNode(node, p), node);
+                else if (!isPrimitive(value)) {
+                    updateTracking(getChildNode(node, p));
                 }
             }
             return vProp;
@@ -542,7 +527,7 @@ const proxyHandler = {
         const keys = value ? Reflect.ownKeys(value) : [];
         // Update that this node was accessed for observers
         if (tracking.nodes) {
-            updateTracking(target, undefined, Tracking.shallow);
+            updateTracking(target, Tracking.shallow);
         }
         // This is required to fix this error:
         // TypeError: 'getOwnPropertyDescriptor' on proxy: trap reported non-configurability for
@@ -606,7 +591,7 @@ function set(node, keyOrNewValue, newValue) {
         return setProp(node, 'value', keyOrNewValue);
     }
     else if (!node.parent) {
-        return setProp(node, undef, keyOrNewValue);
+        return setProp(node, symbolUndef, keyOrNewValue);
     }
     else {
         return setProp(node.parent, node.key, keyOrNewValue);
@@ -618,11 +603,16 @@ function setProp(node, key, newValue, level) {
             console.warn(`[legend-state] Set an HTMLElement into state. You probably don't want to do that.`);
         }
     }
-    const isDelete = newValue === undef;
+    if (node.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 isDelete = newValue === symbolUndef;
     if (isDelete)
         newValue = undefined;
     inSetFn = true;
-    const isRoot = key === undef;
+    const isRoot = key === symbolUndef;
     // Get the child node for updating and notifying
     let childNode = isRoot ? node : getChildNode(node, key);
     // Set operations do not create listeners
@@ -636,11 +626,12 @@ function setProp(node, key, newValue, level) {
     // Save the previous value first
     const prevValue = parentValue[key];
     // Compute newValue if newValue is a function or an observable
-    newValue = isFunction(newValue)
-        ? newValue(prevValue)
-        : isObject(newValue) && (newValue === null || newValue === void 0 ? void 0 : newValue[symbolIsObservable])
-            ? newValue.get()
-            : newValue;
+    newValue =
+        !inAssign && isFunction(newValue)
+            ? newValue(prevValue)
+            : isObject(newValue) && (newValue === null || newValue === void 0 ? void 0 : newValue[symbolIsObservable])
+                ? newValue.get()
+                : newValue;
     const isPrim = isPrimitive(newValue);
     // Save the new value
     if (isDelete) {
@@ -691,10 +682,12 @@ function _notify(node, value, path, valueAtPath, prevAtPath, level, whenOptimize
     if (listeners) {
         let getPrevious;
         for (let listenerFn of listeners) {
-            const shallow = listenerFn[0][0] === 's';
-            const optimized = listenerFn[0][0] === 'o';
-            const listener = listenerFn[1];
-            const ok = shallow ? level <= 0 : optimized ? whenOptimizedOnlyIf && level <= 0 : true;
+            const { track } = listenerFn;
+            const ok = track === Tracking.shallow
+                ? level <= 0
+                : track === 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
@@ -702,7 +695,15 @@ function _notify(node, value, path, valueAtPath, prevAtPath, level, whenOptimize
                 if (!getPrevious) {
                     getPrevious = createPreviousHandler(value, path, prevAtPath);
                 }
-                batchNotify({ cb: listener, value, getPrevious, path, valueAtPath, prevAtPath, node });
+                batchNotify({
+                    cb: listenerFn.listener,
+                    value,
+                    getPrevious,
+                    path,
+                    valueAtPath,
+                    prevAtPath,
+                    node,
+                });
             }
         }
     }
@@ -720,13 +721,10 @@ function _notifyParents(node, value, path, valueAtPath, prevAtPath, level, whenO
     }
 }
 function notify(node, value, prev, level, whenOptimizedOnlyIf) {
-    // Start notifying up through parents with the listenerInfo
+    // Notify self and up through parents
     _notifyParents(node, value, [], value, prev, level, whenOptimizedOnlyIf);
 }
 function assign(node, value) {
-    // Set operations do not create listeners
-    if (tracking.nodes)
-        untrack(node);
     const proxy = getProxy(node);
     beginBatch();
     // Set inAssign to allow setting on safe observables
@@ -744,11 +742,11 @@ function deleteFn(node, key) {
     }
     if (!node.root.isPrimitive) {
         // delete sets to undefined first to notify
-        setProp(node, key, undef, /*level*/ -1);
+        setProp(node, key, symbolUndef, /*level*/ -1);
     }
 }
 function observable(value, safe) {
-    const promise = value.then && value;
+    const promise = (value === null || value === void 0 ? void 0 : value.then) && value;
     if (promise) {
         value = undefined;
     }
@@ -770,8 +768,8 @@ function observable(value, safe) {
     };
     const proxy = getProxy(node);
     if (promise) {
-        promise.catch((rejected) => {
-            proxy.set({ rejected });
+        promise.catch((error) => {
+            proxy.set({ error });
         });
         promise.then((value) => {
             obs.isPrimitive = isPrimitive(value);
@@ -784,41 +782,57 @@ function observable(value, safe) {
     return proxy;
 }
 
-function effect(run) {
+function setupTracking(nodes, update) {
+    let listeners = [];
+    // Listen to tracked nodes
+    for (let tracked of nodes.values()) {
+        const { node, track } = tracked;
+        listeners.push(onChange(node, update, track));
+    }
+    return () => {
+        if (listeners) {
+            for (let i = 0; i < listeners.length; i++) {
+                listeners[i]();
+            }
+            listeners = undefined;
+        }
+    };
+}
+function observe(run) {
+    var _a;
     let cleanup;
     // Wrap it in a function so it doesn't pass all the arguments to run()
-    const update = function () {
+    let update = function () {
+        var _a;
         if (cleanup) {
             cleanup();
             cleanup = undefined;
         }
         cleanup = run();
+        // Do tracing if it was requested
+        if (process.env.NODE_ENV === 'development') {
+            (_a = tracking.listeners) === null || _a === void 0 ? void 0 : _a.call(tracking, tracking.nodes);
+            if (tracking.updates) {
+                update = tracking.updates(update);
+            }
+            // Clear tracing
+            tracking.listeners = undefined;
+            tracking.updates = undefined;
+        }
     };
     const trackingPrev = tracking.nodes;
     tracking.nodes = new Map();
-    cleanup = run();
-    let listeners = [];
-    // Listen to tracked nodes
-    for (let tracked of tracking.nodes.values()) {
-        const { node, track } = tracked;
-        let options;
-        if (track) {
-            options = {
-                shallow: track === Tracking.shallow,
-                optimized: track === Tracking.optimized,
-            };
+    update();
+    // Do tracing if it was requested
+    if (process.env.NODE_ENV === 'development') {
+        (_a = tracking.listeners) === null || _a === void 0 ? void 0 : _a.call(tracking, tracking.nodes);
+        if (tracking.updates) {
+            update = tracking.updates(update);
         }
-        listeners.push(onChange(node, update, options));
     }
+    const ret = setupTracking(tracking.nodes, update);
     tracking.nodes = trackingPrev;
-    return () => {
-        if (listeners) {
-            for (let i = 0; i < listeners.length; i++) {
-                listeners[i]();
-            }
-            listeners = undefined;
-        }
-    };
+    return ret;
 }
 
 function computed(compute) {
@@ -835,7 +849,7 @@ function computed(compute) {
             obs = observable(val);
         }
     };
-    effect(fn);
+    observe(fn);
     return obs;
 }
 
@@ -853,30 +867,26 @@ function event() {
     };
 }
 
-function when(predicate, effect$1, options) {
+function when(predicate, effect) {
     let cleanup;
     let isDone = false;
     // Create a wrapping fn that calls the effect if predicate returns true
-    const fn = function () {
+    function run() {
         const ret = predicate();
         if (ret) {
             // If value is truthy then run the effect and cleanup
-            if (!(options === null || options === void 0 ? void 0 : options.repeat)) {
-                isDone = true;
-            }
-            effect$1();
-            if (isDone) {
-                cleanup === null || cleanup === void 0 ? void 0 : cleanup();
-            }
+            isDone = true;
+            effect();
+            cleanup === null || cleanup === void 0 ? void 0 : cleanup();
         }
-    };
+    }
     // If no effect parameter return a promise
-    const promise = !effect$1 &&
+    const promise = !effect &&
         new Promise((resolve) => {
-            effect$1 = resolve;
+            effect = resolve;
         });
     // Create an effect for the fn
-    cleanup = effect(fn);
+    cleanup = observe(run);
     // If it's already cleanup
     if (isDone) {
         cleanup();
@@ -884,5 +894,5 @@ function when(predicate, effect$1, options) {
     return promise || cleanup;
 }
 
-export { Tracking, batch, beginBatch, computed, effect, endBatch, event, isArray, isEmpty, isFunction, isObject, isObservable, isPrimitive, mergeIntoObservable, observable, onChange, symbolDateModified, symbolIsObservable, tracking, when };
+export { Tracking, batch, beginBatch, computed, endBatch, event, extraPrimitiveProps, getNode, getNodeValue, isArray, isEmpty, isFunction, isObject, isObservable, isPrimitive, lockObservable, mergeIntoObservable, observable, observe, onChange, setupTracking, symbolDateModified, symbolIsObservable, symbolUndef, tracking, when };
 //# sourceMappingURL=index.mjs.map