@legendapp/state 2.0.0-next.9 → 2.0.1

package/index.js

@@ -50,55 +50,14 @@ function isChildNodeValue(node) {
     return !!node.parent;
 }
 
-let trackCount = 0;
-const trackingQueue = [];
-const tracking = {
-    current: undefined,
-    inRender: false,
-};
-function beginTracking(inRender) {
-    // Keep a copy of the previous tracking context so it can be restored
-    // when this context is complete
-    trackingQueue.push(tracking.current);
-    trackCount++;
-    tracking.inRender = inRender;
-    tracking.current = {};
-}
-function endTracking(fromRender) {
-    // Restore the previous tracking context
-    trackCount--;
-    if (trackCount < 0) {
-        trackCount = 0;
-    }
-    if (fromRender) {
-        tracking.inRender = false;
-    }
-    tracking.current = trackingQueue.pop();
-}
-function updateTracking(node, track) {
-    if (trackCount) {
-        const tracker = tracking.current;
-        if (tracker) {
-            if (!tracker.nodes) {
-                tracker.nodes = new Map();
-            }
-            const existing = tracker.nodes.get(node);
-            if (existing) {
-                existing.track = existing.track || track;
-                existing.num++;
-            }
-            else {
-                tracker.nodes.set(node, { node, track, num: 1 });
-            }
-        }
-    }
-}
-
 const symbolToPrimitive = Symbol.toPrimitive;
 const symbolGetNode = Symbol('getNode');
 const symbolDelete = /* @__PURE__ */ Symbol('delete');
 const symbolOpaque = Symbol('opaque');
 const optimized = Symbol('optimized');
+// TODOV3 Remove these
+const extraPrimitiveActivators = new Map();
+const extraPrimitiveProps = new Map();
 const globalState = {
     isLoadingLocal: false,
     isLoadingRemote: false,
@@ -116,15 +75,6 @@ function checkActivate(node) {
 function getNode(obs) {
     return obs && obs[symbolGetNode];
 }
-function get(node, track) {
-    // Track by default
-    updateTracking(node, track);
-    return peek(node);
-}
-function peek(node) {
-    checkActivate(node);
-    return getNodeValue(node);
-}
 function setNodeValue(node, newValue) {
     var _a;
     const parentNode = (_a = node.parent) !== null && _a !== void 0 ? _a : node;
@@ -188,6 +138,7 @@ function getChildNode(node, key) {
             root: node.root,
             parent: node,
             key,
+            lazy: true,
         };
         if (!node.children) {
             node.children = new Map();
@@ -478,6 +429,25 @@ function endBatch(force) {
     }
 }
 
+function createObservable(value, makePrimitive, createObject, createPrimitive) {
+    const valueIsPromise = isPromise(value);
+    const root = {
+        _: value,
+    };
+    const node = {
+        root,
+        lazy: true,
+    };
+    const prim = makePrimitive || isActualPrimitive(value);
+    const obs = prim
+        ? new createPrimitive(node)
+        : createObject(node);
+    if (valueIsPromise) {
+        extractPromise(node, value);
+    }
+    return obs;
+}
+
 function onChange(node, callback, options = {}) {
     const { initial, immediate, noArgs } = options;
     const { trackingType } = options;
@@ -516,6 +486,45 @@ function onChange(node, callback, options = {}) {
     return () => listeners.delete(listener);
 }
 
+let trackCount = 0;
+const trackingQueue = [];
+const tracking = {
+    current: undefined,
+};
+function beginTracking() {
+    // Keep a copy of the previous tracking context so it can be restored
+    // when this context is complete
+    trackingQueue.push(tracking.current);
+    trackCount++;
+    tracking.current = {};
+}
+function endTracking() {
+    // Restore the previous tracking context
+    trackCount--;
+    if (trackCount < 0) {
+        trackCount = 0;
+    }
+    tracking.current = trackingQueue.pop();
+}
+function updateTracking(node, track) {
+    if (trackCount) {
+        const tracker = tracking.current;
+        if (tracker) {
+            if (!tracker.nodes) {
+                tracker.nodes = new Map();
+            }
+            const existing = tracker.nodes.get(node);
+            if (existing) {
+                existing.track = existing.track || track;
+                existing.num++;
+            }
+            else {
+                tracker.nodes.set(node, { node, track, num: 1 });
+            }
+        }
+    }
+}
+
 const ArrayModifiers = new Set([
     'copyWithin',
     'fill',
@@ -678,7 +687,6 @@ function updateNodes(parent, obj, prevValue) {
             const prev = isMap ? prevValue === null || prevValue === void 0 ? void 0 : prevValue.get(key) : prevValue === null || prevValue === void 0 ? void 0 : prevValue[key];
             let isDiff = value !== prev;
             if (isDiff) {
-                extractFunctionOrComputed(parent, obj, key, value);
                 const id = idField && value
                     ? isIdFieldFunction
                         ? idField(value)
@@ -760,7 +768,7 @@ function getProxy(node, p) {
     if (p !== undefined)
         node = getChildNode(node, p);
     // Create a proxy if not already cached and return it
-    return node.proxy || (node.proxy = new Proxy(node, proxyHandler));
+    return (node.proxy || (node.proxy = new Proxy(node, proxyHandler)));
 }
 const proxyHandler = {
     get(node, p, receiver) {
@@ -773,12 +781,13 @@ const proxyHandler = {
         if (p === symbolGetNode) {
             return node;
         }
+        const value = peek(node);
         // If this node is linked to another observable then forward to the target's handler.
         // The exception is onChange because it needs to listen to this node for changes.
+        // This needs to be below peek because it activates there.
         if (node.linkedToNode && p !== 'onChange') {
             return proxyHandler.get(node.linkedToNode, p, receiver);
         }
-        const value = peek(node);
         if (value instanceof Map || value instanceof WeakMap || value instanceof Set || value instanceof WeakSet) {
             const ret = handlerMapSet(node, p, value);
             if (ret !== undefined) {
@@ -817,6 +826,20 @@ const proxyHandler = {
         if (property) {
             return property.get(node);
         }
+        // TODOV3 Remove this
+        const isValuePrimitive = isPrimitive(value);
+        // If accessing a key that doesn't already exist, and this node has been activated with extra keys
+        // then return the values that were set. This is used by enableLegendStateReact for example.
+        if (value === undefined || value === null || isValuePrimitive) {
+            if (extraPrimitiveProps.size && (node.isActivatedPrimitive || extraPrimitiveActivators.has(p))) {
+                node.isActivatedPrimitive = true;
+                const vPrim = extraPrimitiveProps.get(p);
+                if (vPrim !== undefined) {
+                    return isFunction(vPrim) ? vPrim(getProxy(node)) : vPrim;
+                }
+            }
+        }
+        // /TODOV3 Remove this
         const vProp = value === null || value === void 0 ? void 0 : value[p];
         if (isObject(value) && value[symbolOpaque]) {
             return vProp;
@@ -876,6 +899,9 @@ const proxyHandler = {
         if (fnOrComputed) {
             return fnOrComputed;
         }
+        if (p === 'state' && node.state) {
+            return node.state;
+        }
         // Return an observable proxy to the property
         return getProxy(node, p);
     },
@@ -986,7 +1012,7 @@ function setKey(node, key, newValue, level) {
     if (savedValue !== prevValue) {
         updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level);
     }
-    extractFunctionOrComputed(node, parentValue, key, newValue);
+    extractFunctionOrComputed(node, parentValue, key, savedValue);
     return isFunc ? savedValue : isRoot ? getProxy(node) : getProxy(node, key);
 }
 function assign(node, value) {
@@ -1114,16 +1140,20 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
     endBatch();
 }
 function extractPromise(node, value) {
-    value.status = 'pending';
+    if (!node.state) {
+        node.state = createObservable({
+            isLoaded: false,
+        }, false, getProxy);
+    }
     value
         .then((value) => {
         set(node, value);
+        node.state.isLoaded.set(true);
     })
         .catch((error) => {
-        set(node, { error, status: 'rejected' });
+        node.state.error.set(error);
     });
 }
-const __devExtractFunctionsAndComputedsNodes = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test' ? new Set() : undefined;
 function extractFunctionOrComputed(node, obj, k, v) {
     if (isPromise(v)) {
         extractPromise(getChildNode(node, k), v);
@@ -1142,21 +1172,26 @@ function extractFunctionOrComputed(node, obj, k, v) {
         }
     }
 }
-function extractFunctionsAndComputeds(node, obj) {
-    if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') &&
-        typeof __devExtractFunctionsAndComputedsNodes !== 'undefined') {
-        if (__devExtractFunctionsAndComputedsNodes.has(obj)) {
-            console.error('[legend-state] Circular reference detected in object. You may want to use opaqueObject to stop traversing child nodes.', obj);
-            return false;
-        }
-        __devExtractFunctionsAndComputedsNodes.add(obj);
-    }
-    for (const k in obj) {
-        const v = obj[k];
-        if (v && extractFunctionOrComputed(node, obj, k, v) && !v[symbolOpaque]) {
-            extractFunctionsAndComputeds(getChildNode(node, k), v);
+function get(node, options) {
+    const track = options ? (isObject(options) ? options.shallow : options) : undefined;
+    // Track by default
+    updateTracking(node, track);
+    return peek(node);
+}
+function peek(node) {
+    const value = getNodeValue(node);
+    // If node is not yet lazily computed go do that
+    if (node.lazy) {
+        delete node.lazy;
+        for (const key in value) {
+            if (hasOwnProperty.call(value, key)) {
+                extractFunctionOrComputed(node, value, key, value[key]);
+            }
         }
     }
+    // Check if computed needs to activate
+    checkActivate(node);
+    return value;
 }
 
 function isObservable(obs) {
@@ -1226,11 +1261,14 @@ function setAtPath(obj, path, pathTypes, value, fullObj, restore) {
     }
     return obj;
 }
-function setInObservableAtPath(obs, path, value, mode) {
+function setInObservableAtPath(obs, path, pathTypes, value, mode) {
     let o = obs;
     let v = value;
     for (let i = 0; i < path.length; i++) {
         const p = path[i];
+        if (!o.peek()[p] && pathTypes[i] === 'array') {
+            o[p].set([]);
+        }
         o = o[p];
         v = v[p];
     }
@@ -1295,7 +1333,7 @@ function _mergeIntoObservable(target, source) {
     }
     return target;
 }
-function constructObjectWithPath(path, value, pathTypes) {
+function constructObjectWithPath(path, pathTypes, value) {
     let out;
     if (path.length > 0) {
         let o = (out = {});
@@ -1310,11 +1348,11 @@ function constructObjectWithPath(path, value, pathTypes) {
     }
     return out;
 }
-function deconstructObjectWithPath(path, value) {
+function deconstructObjectWithPath(path, pathTypes, value) {
     let o = value;
     for (let i = 0; i < path.length; i++) {
         const p = path[i];
-        o = o[p];
+        o = o ? o[p] : pathTypes[i] === 'array' ? [] : {};
     }
     return o;
 }
@@ -1367,36 +1405,11 @@ ObservablePrimitiveClass.prototype.delete = function () {
     return this;
 };
 
-function createObservable(value, makePrimitive) {
-    const valueIsPromise = isPromise(value);
-    const root = {
-        _: value,
-    };
-    const node = {
-        root,
-    };
-    const prim = makePrimitive || isActualPrimitive(value);
-    const obs = prim
-        ? new ObservablePrimitiveClass(node)
-        : getProxy(node);
-    if (valueIsPromise) {
-        extractPromise(node, value);
-    }
-    else if (!prim) {
-        if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-            __devExtractFunctionsAndComputedsNodes.clear();
-        }
-        if (value) {
-            extractFunctionsAndComputeds(node, value);
-        }
-    }
-    return obs;
-}
 function observable(value) {
-    return createObservable(value);
+    return createObservable(value, false, getProxy, ObservablePrimitiveClass);
 }
 function observablePrimitive(value) {
-    return createObservable(value, /*makePrimitive*/ true);
+    return createObservable(value, true, getProxy, ObservablePrimitiveClass);
 }
 
 function setupTracking(nodes, update, noArgs, immediate) {
@@ -1416,7 +1429,7 @@ function setupTracking(nodes, update, noArgs, immediate) {
     };
 }
 
-function trackSelector(selector, update, observeEvent, observeOptions, createResubscribe, inRender) {
+function trackSelector(selector, update, observeEvent, observeOptions, createResubscribe) {
     var _a;
     let nodes;
     let value;
@@ -1424,23 +1437,21 @@ function trackSelector(selector, update, observeEvent, observeOptions, createRes
     let tracker;
     let resubscribe;
     let updateFn = update;
-    let noArgs = true;
     if (isObservable(selector)) {
         value = selector.peek();
-        dispose = selector.onChange(update, { noArgs: true });
-        resubscribe = createResubscribe ? selector.onChange(update, { noArgs: true }) : undefined;
+        dispose = selector.onChange(update);
+        resubscribe = createResubscribe ? selector.onChange(update) : undefined;
     }
     else {
         // Compute the selector inside a tracking context
-        beginTracking(inRender);
-        value = selector ? computeSelector(selector, observeEvent, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.retainObservable) : selector;
+        beginTracking();
+        value = selector ? computeSelector(selector, observeEvent, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.fromComputed) : selector;
         tracker = tracking.current;
         nodes = tracker.nodes;
-        endTracking(inRender);
+        endTracking();
         if ((process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') && tracker && nodes) {
             (_a = tracker.traceListeners) === null || _a === void 0 ? void 0 : _a.call(tracker, nodes);
             if (tracker.traceUpdates) {
-                noArgs = false;
                 updateFn = tracker.traceUpdates(update);
             }
             // Clear tracing so it doesn't leak to other components
@@ -1452,8 +1463,8 @@ function trackSelector(selector, update, observeEvent, observeOptions, createRes
         // Do tracing if it was requested
         // useSyncExternalStore doesn't subscribe until after the component mount.
         // We want to subscribe immediately so we don't miss any updates
-        dispose = setupTracking(nodes, updateFn, noArgs, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.immediate);
-        resubscribe = createResubscribe ? () => setupTracking(nodes, updateFn, noArgs) : undefined;
+        dispose = setupTracking(nodes, updateFn, false, observeOptions === null || observeOptions === void 0 ? void 0 : observeOptions.immediate);
+        resubscribe = createResubscribe ? () => setupTracking(nodes, updateFn) : undefined;
     }
     return { value, dispose, resubscribe };
 }
@@ -1487,15 +1498,17 @@ function observe(selectorOrRun, reactionOrOptions, options) {
             e.onCleanupReaction();
             e.onCleanupReaction = undefined;
         }
+        endBatch();
         // Call the reaction if there is one and the value changed
-        if (reaction && (e.num > 0 || !isEvent(selectorOrRun)) && e.previous !== e.value) {
+        if (reaction &&
+            (e.num > 0 || !isEvent(selectorOrRun)) &&
+            (e.previous !== e.value || (options === null || options === void 0 ? void 0 : options.fromComputed))) {
             reaction(e);
         }
         // Update the previous value
         e.previous = e.value;
         // Increment the counter
         e.num++;
-        endBatch();
     };
     update();
     // Return function calling dispose because dispose may be changed in update()
@@ -1582,7 +1595,7 @@ function computed(compute, set$1) {
             else {
                 setInner(value);
             }
-        }, { immediate: true, retainObservable: true });
+        }, { immediate: true, fromComputed: true });
     };
     if (set$1) {
         node.root.set = (value) => {
@@ -1672,20 +1685,27 @@ function proxy(get, set) {
 }
 
 function _when(predicate, effect, checkReady) {
+    // If predicate is a regular Promise skip all the observable stuff
+    if (isPromise(predicate)) {
+        return effect ? predicate.then(effect) : predicate;
+    }
     let value;
     // 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)) {
             value = ret;
-            // If value is truthy then run the effect
-            effect === null || effect === void 0 ? void 0 : effect(ret);
-            // Set cancel so that observe does not track
+            // Set cancel so that observe does not track anymore
             e.cancel = true;
         }
+        return value;
+    }
+    function doEffect() {
+        // If value is truthy then run the effect
+        effect === null || effect === void 0 ? void 0 : effect(value);
     }
     // Run in an observe
-    observe(run);
+    observe(run, doEffect);
     // If first run resulted in a truthy value just return it.
     // It will have set e.cancel so no need to dispose
     if (isPromise(value)) {
@@ -1725,6 +1745,7 @@ const internal = {
     getNode,
     getProxy,
     globalState,
+    observableFns,
     optimized,
     peek,
     set,
@@ -1746,10 +1767,13 @@ exports.deconstructObjectWithPath = deconstructObjectWithPath;
 exports.endBatch = endBatch;
 exports.endTracking = endTracking;
 exports.event = event;
+exports.extraPrimitiveActivators = extraPrimitiveActivators;
+exports.extraPrimitiveProps = extraPrimitiveProps;
 exports.findIDKey = findIDKey;
 exports.getNode = getNode;
 exports.getNodeValue = getNodeValue;
 exports.getObservableIndex = getObservableIndex;
+exports.hasOwnProperty = hasOwnProperty;
 exports.internal = internal;
 exports.isArray = isArray;
 exports.isBoolean = isBoolean;