@legendapp/state 0.15.0-next.9 → 0.15.0

package/index.d.ts

@@ -4,10 +4,11 @@ export { observable } from './src/observable';
 export { batch, beginBatch, endBatch } from './src/batching';
 export { computed } from './src/computed';
 export { event } from './src/event';
-export { effect } from './src/effect';
+export { observe } from './src/observe';
 export { when } from './src/when';
 export * from './src/observableInterfaces';
 export { isEmpty } from './src/is';
+export { lockObservable } from './src/helpers';
 /** @internal */
 export { isArray, isFunction, isObject, isPrimitive } from './src/is';
 /** @internal */
@@ -15,4 +16,8 @@ export { onChange } from './src/onChange';
 /** @internal */
 export { tracking } from './src/tracking';
 /** @internal */
-export { symbolDateModified, symbolIsObservable } from './src/globals';
+export { symbolDateModified, symbolIsObservable, extraPrimitiveProps, getNodeValue, symbolUndef } from './src/globals';
+/** @internal */
+export { getNode } from './src/helpers';
+/** @internal */
+export { setupTracking } from './src/observe';

package/index.js

@@ -40,10 +40,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;
@@ -68,6 +65,9 @@ function untrack(node) {
 
 const symbolDateModified = Symbol('dateModified');
 const symbolIsObservable = Symbol('isObservable');
+const symbolGetNode = Symbol('getNode');
+const symbolUndef = Symbol('undef');
+const extraPrimitiveProps = new Map();
 exports.Tracking = void 0;
 (function (Tracking) {
     Tracking.normal = true;
@@ -78,7 +78,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);
@@ -90,10 +90,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 ? exports.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 = [];
@@ -110,13 +113,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)) {
@@ -147,6 +143,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)
@@ -234,33 +240,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();
-    }
-    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);
-        }
+        node.listeners = listeners = new Set();
     }
-    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',
@@ -277,7 +270,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],
@@ -290,28 +283,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;
@@ -326,14 +318,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 =
@@ -363,8 +347,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);
                 }
             }
@@ -418,8 +401,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);
                     }
                 }
@@ -431,7 +413,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;
@@ -442,13 +423,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;
@@ -456,25 +433,27 @@ function ref(node, keyOrTrack, track) {
     if (keyOrTrack !== undefined) {
         node = getChildNode(node, keyOrTrack);
     }
-    // Untrack by default
-    checkTracking(node, track === true ? exports.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 ? exports.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.
@@ -500,7 +479,7 @@ const proxyHandler = {
                     // Update that this node was accessed for observers
                     // Listen to the array shallowly
                     if (tracking.nodes) {
-                        updateTracking(node, undefined, exports.Tracking.shallow);
+                        updateTracking(node, exports.Tracking.shallow);
                     }
                     return function (cbOrig, thisArg) {
                         function cb(_, index, array) {
@@ -515,6 +494,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;
@@ -522,13 +507,13 @@ const proxyHandler = {
             // Update that this primitive node was accessed for observers
             if (tracking.nodes) {
                 if (isArray(value) && p === 'length') {
-                    updateTracking(node, undefined, exports.Tracking.shallow);
+                    updateTracking(node, exports.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;
@@ -546,7 +531,7 @@ const proxyHandler = {
         const keys = value ? Reflect.ownKeys(value) : [];
         // Update that this node was accessed for observers
         if (tracking.nodes) {
-            updateTracking(target, undefined, exports.Tracking.shallow);
+            updateTracking(target, exports.Tracking.shallow);
         }
         // This is required to fix this error:
         // TypeError: 'getOwnPropertyDescriptor' on proxy: trap reported non-configurability for
@@ -610,7 +595,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);
@@ -622,11 +607,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
@@ -695,11 +685,12 @@ function _notify(node, value, path, valueAtPath, prevAtPath, level, whenOptimize
     if (listeners) {
         let getPrevious;
         for (let listenerFn of listeners) {
-            const track = listenerFn[0][0];
-            const shallow = track === 's';
-            const optimized = track === 'o';
-            const listener = listenerFn[1];
-            const ok = shallow ? level <= 0 : optimized ? whenOptimizedOnlyIf && level <= 0 : true;
+            const { track } = 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
@@ -707,7 +698,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,
+                });
             }
         }
     }
@@ -729,9 +728,6 @@ function notify(node, value, prev, level, whenOptimizedOnlyIf) {
     _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
@@ -749,7 +745,7 @@ 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) {
@@ -794,14 +790,7 @@ function setupTracking(nodes, update) {
     // Listen to tracked nodes
     for (let tracked of nodes.values()) {
         const { node, track } = tracked;
-        let options;
-        if (track) {
-            options = {
-                shallow: track === exports.Tracking.shallow,
-                optimized: track === exports.Tracking.optimized,
-            };
-        }
-        listeners.push(onChange(node, update, options));
+        listeners.push(onChange(node, update, track));
     }
     return () => {
         if (listeners) {
@@ -812,19 +801,38 @@ function setupTracking(nodes, update) {
         }
     };
 }
-function effect(run) {
+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();
+    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);
+        }
+    }
     const ret = setupTracking(tracking.nodes, update);
     tracking.nodes = trackingPrev;
     return ret;
@@ -844,7 +852,7 @@ function computed(compute) {
             obs = observable(val);
         }
     };
-    effect(fn);
+    observe(fn);
     return obs;
 }
 
@@ -862,30 +870,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();
@@ -896,20 +900,26 @@ function when(predicate, effect$1, options) {
 exports.batch = batch;
 exports.beginBatch = beginBatch;
 exports.computed = computed;
-exports.effect = effect;
 exports.endBatch = endBatch;
 exports.event = event;
+exports.extraPrimitiveProps = extraPrimitiveProps;
+exports.getNode = getNode;
+exports.getNodeValue = getNodeValue;
 exports.isArray = isArray;
 exports.isEmpty = isEmpty;
 exports.isFunction = isFunction;
 exports.isObject = isObject;
 exports.isObservable = isObservable;
 exports.isPrimitive = isPrimitive;
+exports.lockObservable = lockObservable;
 exports.mergeIntoObservable = mergeIntoObservable;
 exports.observable = observable;
+exports.observe = observe;
 exports.onChange = onChange;
+exports.setupTracking = setupTracking;
 exports.symbolDateModified = symbolDateModified;
 exports.symbolIsObservable = symbolIsObservable;
+exports.symbolUndef = symbolUndef;
 exports.tracking = tracking;
 exports.when = when;
 //# sourceMappingURL=index.js.map