@legendapp/state 2.2.0-next.37 → 2.2.0-next.38

package/index.d.ts

@@ -4,7 +4,7 @@ export { computed } from './src/computed';
 export { configureLegendState } from './src/config';
 export { event } from './src/event';
 export { isObservable } from './src/globals';
-export { computeSelector, constructObjectWithPath, deconstructObjectWithPath, getObservableIndex, isObservableValueReady, lockObservable, mergeIntoObservable, opaqueObject, setAtPath, setInObservableAtPath, setSilently, } from './src/helpers';
+export { computeSelector, constructObjectWithPath, deconstructObjectWithPath, getObservableIndex, isObservableValueReady, mergeIntoObservable, opaqueObject, setAtPath, setInObservableAtPath, setSilently, } from './src/helpers';
 export { hasOwnProperty, isArray, isBoolean, isEmpty, isFunction, isObject, isPrimitive, isPromise, isString, isSymbol, } from './src/is';
 export { observable, observablePrimitive, syncState } from './src/observable';
 export * from './src/observableInterfaces';

package/index.js

@@ -73,24 +73,11 @@ const globalState = {
 function isObservable(obs) {
     return !!obs && !!obs[symbolGetNode];
 }
-function isComputed(obs) {
-    var _a;
-    return obs && ((_a = obs[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isComputed);
-}
-function checkActivate(node) {
-    var _a;
-    const root = node.root;
-    (_a = root.activate) === null || _a === void 0 ? void 0 : _a.call(root);
-    if (root.toActivate) {
-        root.toActivate.forEach(checkActivate);
-        delete root.toActivate;
-    }
-}
 function getNode(obs) {
     return obs && obs[symbolGetNode];
 }
 function setNodeValue(node, newValue) {
-    var _a;
+    var _a, _b, _c;
     const parentNode = (_a = node.parent) !== null && _a !== void 0 ? _a : node;
     const key = node.parent ? node.key : '_';
     const isDelete = newValue === symbolDelete;
@@ -105,28 +92,30 @@ function setNodeValue(node, newValue) {
     // Compute newValue if newValue is a function or an observable
     newValue = !parentNode.isAssigning && isFunc ? newValue(prevValue) : newValue;
     // If setting an observable, set a link to the observable instead
-    if (isObservable(newValue) && !isComputed(newValue)) {
+    if (isObservable(newValue)) {
         const val = newValue;
         node.lazy = true;
         node.lazyFn = () => val;
         newValue = undefined;
     }
-    try {
-        parentNode.isSetting = (parentNode.isSetting || 0) + 1;
-        // Save the new value
-        if (isDelete) {
-            delete parentValue[key];
+    if (!globalState.isMerging ||
+        prevValue === undefined ||
+        isFunction(prevValue) ||
+        !((_c = (_b = node.parent) === null || _b === void 0 ? void 0 : _b.functions) === null || _c === void 0 ? void 0 : _c.get(key))) {
+        try {
+            parentNode.isSetting = (parentNode.isSetting || 0) + 1;
+            // Save the new value
+            if (isDelete) {
+                delete parentValue[key];
+            }
+            else {
+                parentValue[key] = newValue;
+            }
         }
-        else {
-            parentValue[key] = newValue;
+        finally {
+            parentNode.isSetting--;
         }
     }
-    finally {
-        parentNode.isSetting--;
-    }
-    if (parentNode.root.locked && parentNode.root.set) {
-        parentNode.root.set(parentNode.root._);
-    }
     return { prevValue, newValue, parentValue };
 }
 const arrNodeKeys = [];
@@ -210,18 +199,11 @@ function findIDKey(obj, node) {
     }
     return idKey;
 }
-function extractFunction(node, key, fnOrComputed, computedChildNode) {
+function extractFunction(node, key, fnOrComputed) {
     if (!node.functions) {
         node.functions = new Map();
     }
     node.functions.set(key, fnOrComputed);
-    if (computedChildNode) {
-        computedChildNode.parentOther = getChildNode(node, key);
-        if (!node.root.toActivate) {
-            node.root.toActivate = [];
-        }
-        node.root.toActivate.push(computedChildNode);
-    }
 }
 
 function activated(params) {
@@ -524,13 +506,6 @@ function opaqueObject(value) {
     }
     return value;
 }
-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 setAtPath(obj, path, pathTypes, value, fullObj, restore) {
     let o = obj;
     let oFull = fullObj;
@@ -686,7 +661,6 @@ function onChange(node, callback, options = {}) {
             node.listeners = listeners;
         }
     }
-    checkActivate(node);
     const listener = {
         listener: callback,
         track: trackingType,
@@ -1025,6 +999,7 @@ if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
 function collectionSetter(node, target, prop, ...args) {
     var _a;
     if (prop === 'push' && args.length === 1) {
+        // Fast path for push to just append to the end
         setKey(node, target.length + '', args[0]);
     }
     else {
@@ -1266,7 +1241,7 @@ const proxyHandler = {
         if (p === symbolGetNode) {
             return node;
         }
-        const value = peek(node);
+        let 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.
@@ -1303,14 +1278,6 @@ const proxyHandler = {
                 }
             };
         }
-        if (node.isComputed) {
-            if (node.proxyFn && !fn) {
-                return node.proxyFn(p);
-            }
-            else {
-                checkActivate(node);
-            }
-        }
         const property = observableProperties.get(p);
         if (property) {
             return property.get(node);
@@ -1329,7 +1296,7 @@ const proxyHandler = {
             }
         }
         // /TODOV3 Remove this
-        const vProp = value === null || value === void 0 ? void 0 : value[p];
+        let vProp = value === null || value === void 0 ? void 0 : value[p];
         if (isObject(value) && value[symbolOpaque]) {
             return vProp;
         }
@@ -1342,6 +1309,11 @@ const proxyHandler = {
                 return getProxy(node, p, fnOrComputed);
             }
         }
+        if (value === undefined && vProp === undefined && (ArrayModifiers.has(p) || ArrayLoopers.has(p))) {
+            value = [];
+            setNodeValue(node, value);
+            vProp = value[p];
+        }
         // Handle function calls
         if (isFunction(vProp)) {
             if (isArray(value)) {
@@ -1483,20 +1455,6 @@ function setKey(node, key, newValue, level) {
         }
     }
     const isRoot = !node.parent && key === '_';
-    // TODOv3 root locking will be removed with old computeds
-    if (node.root.locked && !node.root.set) {
-        // This happens when modifying a locked observable such as a computed.
-        // If merging this could be happening deep in a hierarchy so we don't want to throw errors so we'll just do nothing.
-        // This could happen during persistence local load for example.
-        if (globalState.isMerging) {
-            return isRoot ? getProxy(node) : getProxy(node, key);
-        }
-        else {
-            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');
-        }
-    }
     if (node.parent && !getNodeValue(node)) {
         return set(node, { [key]: newValue });
     }
@@ -1546,7 +1504,13 @@ function deleteFn(node, key) {
         key = node.key;
         node = node.parent;
     }
-    setKey(node, key !== null && key !== void 0 ? key : '_', symbolDelete, /*level*/ -1);
+    const value = getNodeValue(node);
+    if (isArray(value)) {
+        collectionSetter(node, value, 'splice', key, 1);
+    }
+    else {
+        setKey(node, key !== null && key !== void 0 ? key : '_', symbolDelete, /*level*/ -1);
+    }
 }
 function handlerMapSet(node, p, value) {
     const vProp = value === null || value === void 0 ? void 0 : value[p];
@@ -1672,7 +1636,7 @@ function extractFunctionOrComputed(node, obj, k, v) {
         extractPromise(childNode, v);
         setNodeValue(childNode, undefined);
     }
-    else if (isObservable(v) && !isComputed(v)) {
+    else if (isObservable(v)) {
         const value = getNodeValue(node);
         value[k] = () => v;
         extractFunction(node, k, value[k]);
@@ -1689,16 +1653,9 @@ function extractFunctionOrComputed(node, obj, k, v) {
         }
     }
     else if (typeof v == 'object' && v !== null && v !== undefined) {
-        const childNode = getNode(v);
-        if (childNode === null || childNode === void 0 ? void 0 : childNode.isComputed) {
-            extractFunction(node, k, v, childNode);
-        }
-        else if (isObservable(v)) {
+        if (isObservable(v)) {
             extractFunction(node, k, v);
         }
-        else {
-            return true;
-        }
     }
 }
 function get(node, options) {
@@ -1720,12 +1677,6 @@ function peek(node) {
         const lazyFn = node.lazyFn;
         delete node.lazy;
         if (isFunction(node) || isFunction(lazyFn)) {
-            if (node.parent) {
-                const parentValue = getNodeValue(node.parent);
-                if (parentValue) {
-                    delete parentValue[node.key];
-                }
-            }
             value = activateNodeFunction(node, lazyFn);
         }
     }
@@ -1736,9 +1687,6 @@ function peek(node) {
             }
         }
     }
-    // TODOV3 Remove legacy computed
-    // Check if computed needs to activate
-    checkActivate(node);
     return value;
 }
 function reactivateNode(node, lazyFn) {
@@ -2125,87 +2073,15 @@ function syncState(obs) {
 }
 globalState.isLoadingRemote$ = observable(false);
 
-function computed(compute, set$1) {
-    // Create an observable for this computed variable
-    const obs = observable();
-    lockObservable(obs, true);
-    const node = getNode(obs);
-    node.isComputed = true;
-    let isSetAfterActivated = false;
-    const setInner = function (val) {
-        const prevNode = node.linkedToNode;
-        // If it was previously linked to a node remove self
-        // from its linkedFromNodes
-        if (prevNode) {
-            prevNode.linkedFromNodes.delete(node);
-            node.linkedToNode = undefined;
-        }
-        const { parentOther } = node;
-        if (isObservable(val)) {
-            // If the computed is a proxy to another observable
-            // link it to the target observable
-            const linkedNode = getNode(val);
-            node.linkedToNode = linkedNode;
-            if (!linkedNode.linkedFromNodes) {
-                linkedNode.linkedFromNodes = new Set();
-            }
-            linkedNode.linkedFromNodes.add(node);
-            if (node.parentOther) {
-                onChange(linkedNode, ({ value }) => {
-                    setNodeValue(node.parentOther, value);
-                }, { initial: true });
-            }
-            // If the target observable is different then notify for the change
-            if (prevNode) {
-                const value = getNodeValue(linkedNode);
-                const prevValue = getNodeValue(prevNode);
-                notify(node, value, prevValue, 0);
-            }
-        }
-        else if (val !== obs.peek()) {
-            // Unlock computed node before setting the value
-            lockObservable(obs, false);
-            const setter = isSetAfterActivated ? set : setNodeValue;
-            // Update the computed value
-            setter(node, val);
-            // If the computed is a child of an observable set the value on it
-            if (parentOther) {
-                let didUnlock = false;
-                if (parentOther.root.locked) {
-                    parentOther.root.locked = false;
-                    didUnlock = true;
-                }
-                setter(parentOther, val);
-                if (didUnlock) {
-                    parentOther.root.locked = true;
-                }
-            }
-            // Re-lock the computed node
-            lockObservable(obs, true);
-        }
-        else if (parentOther) {
-            setNodeValue(parentOther, val);
-        }
-        isSetAfterActivated = true;
-    };
-    // Lazily activate the observable when get is called
-    node.root.activate = () => {
-        node.root.activate = undefined;
-        observe(compute, ({ value }) => {
-            if (isPromise(value)) {
-                value.then((v) => setInner(v));
-            }
-            else {
-                setInner(value);
-            }
-        }, { immediate: true, fromComputed: true });
-    };
-    if (set$1) {
-        node.root.set = (value) => {
-            batch(() => set$1(value));
-        };
-    }
-    return obs;
+function computed(compute, set) {
+    // @ts-expect-error asdf
+    return observable(set
+        ? activated({
+            // @ts-expect-error asdf
+            get: compute,
+            onSet: ({ value }) => set(value),
+        })
+        : compute);
 }
 
 function configureLegendState({ observableFunctions, observableProperties: observableProperties$1, }) {
@@ -2259,32 +2135,14 @@ function event() {
 }
 
 function proxy(get, set) {
-    // Create an observable for this computed variable
-    const obs = observable({});
-    lockObservable(obs, true);
-    const mapTargets = new Map();
-    const node = getNode(obs);
-    node.isComputed = true;
-    node.proxyFn = (key) => {
-        let target = mapTargets.get(key);
-        if (!target) {
-            // Note: Coercing typescript to allow undefined for set in computed because we don't want the public interface to allow undefined
-            target = computed(() => get(key), (set ? (value) => set(key, value) : undefined));
-            mapTargets.set(key, target);
-            extractFunction(node, key, target, getNode(target));
-            if (node.parentOther) {
-                onChange(getNode(target), ({ value, getPrevious }) => {
-                    const previous = getPrevious();
-                    // Set the raw value on the proxy's parent
-                    setNodeValue(node.parentOther, node.root._);
-                    // Notify the proxy
-                    notify(getChildNode(node, key), value, previous, 0);
-                });
-            }
-        }
-        return target;
-    };
-    return obs;
+    return observable(activated({
+        lookup: (key) => set
+            ? activated({
+                get: () => get(key),
+                onSet: ({ value }) => set(key, value),
+            })
+            : get(key),
+    }));
 }
 
 const internal = {
@@ -2310,7 +2168,6 @@ exports.activated = activated;
 exports.batch = batch;
 exports.beginBatch = beginBatch;
 exports.beginTracking = beginTracking;
-exports.checkActivate = checkActivate;
 exports.computeSelector = computeSelector;
 exports.computed = computed;
 exports.configureLegendState = configureLegendState;
@@ -2338,7 +2195,6 @@ exports.isPrimitive = isPrimitive;
 exports.isPromise = isPromise;
 exports.isString = isString;
 exports.isSymbol = isSymbol;
-exports.lockObservable = lockObservable;
 exports.mergeIntoObservable = mergeIntoObservable;
 exports.observable = observable;
 exports.observablePrimitive = observablePrimitive;