@legendapp/state 2.1.1 → 2.1.3

package/index.d.ts

@@ -12,21 +12,26 @@ export { trackSelector } from './src/trackSelector';
 export { when, whenReady } from './src/when';
 import { get, getProxy, peek, set } from './src/ObservableObject';
 import { ensureNodeValue, findIDKey, getNode, setNodeValue } from './src/globals';
-import { setAtPath } from './src/helpers';
+import { getPathType, setAtPath, initializePathType, safeParse, safeStringify, clone } from './src/helpers';
 export declare const internal: {
+    clone: typeof clone;
     ensureNodeValue: typeof ensureNodeValue;
     findIDKey: typeof findIDKey;
     get: typeof get;
     getNode: typeof getNode;
+    getPathType: typeof getPathType;
     getProxy: typeof getProxy;
     globalState: {
         isLoadingLocal: boolean;
         isLoadingRemote: boolean;
         isMerging: boolean;
     };
+    initializePathType: typeof initializePathType;
     observableFns: Map<string, (node: import("./src/observableInterfaces").NodeValue, ...args: any[]) => any>;
     optimized: symbol;
     peek: typeof peek;
+    safeParse: typeof safeParse;
+    safeStringify: typeof safeStringify;
     set: typeof set;
     setAtPath: typeof setAtPath;
     setNodeValue: typeof setNodeValue;

package/index.js

@@ -194,6 +194,228 @@ function extractFunction(node, key, fnOrComputed, computedChildNode) {
     }
 }
 
+function isObservable(obs) {
+    return obs && !!obs[symbolGetNode];
+}
+function isEvent(obs) {
+    var _a;
+    return obs && ((_a = obs[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isEvent);
+}
+function computeSelector(selector, e, retainObservable) {
+    let c = selector;
+    if (isFunction(c)) {
+        c = e ? c(e) : c();
+    }
+    return isObservable(c) && !retainObservable ? c.get() : c;
+}
+function getObservableIndex(obs) {
+    const node = getNode(obs);
+    const n = +node.key;
+    return n - n < 1 ? +n : -1;
+}
+function opaqueObject(value) {
+    if (value) {
+        value[symbolOpaque] = true;
+    }
+    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;
+    if (path.length > 0) {
+        for (let i = 0; i < path.length; i++) {
+            const p = path[i];
+            if (i === path.length - 1) {
+                // Don't set if the value is the same. This prevents creating a new key
+                // when setting undefined on an object without this key
+                if (o[p] !== value) {
+                    o[p] = value;
+                }
+            }
+            else if (o[p] === symbolDelete) {
+                // If this was previously deleted, restore it
+                if (oFull) {
+                    o[p] = oFull[p];
+                    restore === null || restore === void 0 ? void 0 : restore(path.slice(0, i + 1), o[p]);
+                }
+                break;
+            }
+            else if (o[p] === undefined || o[p] === null) {
+                o[p] = initializePathType(pathTypes[i]);
+            }
+            o = o[p];
+            if (oFull) {
+                oFull = oFull[p];
+            }
+        }
+    }
+    else {
+        obj = value;
+    }
+    return obj;
+}
+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]) {
+            o[p].set(initializePathType(pathTypes[i]));
+        }
+        o = o[p];
+        v = v[p];
+    }
+    if (v === symbolDelete) {
+        o.delete();
+    }
+    // Assign if possible, or set otherwise
+    else if (mode === 'assign' && o.assign && isObject(o.peek())) {
+        o.assign(v);
+    }
+    else {
+        o.set(v);
+    }
+}
+function mergeIntoObservable(target, ...sources) {
+    beginBatch();
+    globalState.isMerging = true;
+    for (let i = 0; i < sources.length; i++) {
+        target = _mergeIntoObservable(target, sources[i]);
+    }
+    globalState.isMerging = false;
+    endBatch();
+    return target;
+}
+function _mergeIntoObservable(target, source) {
+    var _a;
+    const needsSet = isObservable(target);
+    const targetValue = needsSet ? target.peek() : target;
+    const isTargetArr = isArray(targetValue);
+    const isTargetObj = !isTargetArr && isObject(targetValue);
+    if ((isTargetObj && isObject(source) && !isEmpty(targetValue)) ||
+        (isTargetArr && isArray(source) && targetValue.length > 0)) {
+        const keys = Object.keys(source);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const sourceValue = source[key];
+            if (sourceValue === symbolDelete) {
+                needsSet && ((_a = target[key]) === null || _a === void 0 ? void 0 : _a.delete) ? target[key].delete() : delete target[key];
+            }
+            else {
+                const isObj = isObject(sourceValue);
+                const isArr = !isObj && isArray(sourceValue);
+                const targetChild = target[key];
+                if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
+                    if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
+                        target[key] = sourceValue;
+                    }
+                    else {
+                        _mergeIntoObservable(targetChild, sourceValue);
+                    }
+                }
+                else {
+                    needsSet
+                        ? targetChild.set(sourceValue)
+                        : (target[key] = sourceValue);
+                }
+            }
+        }
+    }
+    else if (source !== undefined) {
+        needsSet ? target.set(source) : (target = source);
+    }
+    return target;
+}
+function constructObjectWithPath(path, pathTypes, value) {
+    let out;
+    if (path.length > 0) {
+        let o = (out = {});
+        for (let i = 0; i < path.length; i++) {
+            const p = path[i];
+            o[p] = i === path.length - 1 ? value : initializePathType(pathTypes[i]);
+            o = o[p];
+        }
+    }
+    else {
+        out = value;
+    }
+    return out;
+}
+function deconstructObjectWithPath(path, pathTypes, value) {
+    let o = value;
+    for (let i = 0; i < path.length; i++) {
+        const p = path[i];
+        o = o ? o[p] : initializePathType(pathTypes[i]);
+    }
+    return o;
+}
+function isObservableValueReady(value) {
+    return !!value && ((!isObject(value) && !isArray(value)) || !isEmpty(value));
+}
+function setSilently(obs, newValue) {
+    const node = getNode(obs);
+    return setNodeValue(node, newValue).newValue;
+}
+function getPathType(value) {
+    return isArray(value) ? 'array' : value instanceof Map ? 'map' : value instanceof Set ? 'set' : 'object';
+}
+function initializePathType(pathType) {
+    switch (pathType) {
+        case 'array':
+            return [];
+        case 'object':
+            return {};
+        case 'map':
+            return new Map();
+        case 'set':
+            return new Set();
+    }
+}
+function replacer(_, value) {
+    if (value instanceof Map) {
+        return {
+            __LSType: 'Map',
+            value: Array.from(value.entries()), // or with spread: value: [...value]
+        };
+    }
+    else if (value instanceof Set) {
+        return {
+            __LSType: 'Set',
+            value: Array.from(value), // or with spread: value: [...value]
+        };
+    }
+    else {
+        return value;
+    }
+}
+function reviver(_, value) {
+    if (typeof value === 'object' && value) {
+        if (value.__LSType === 'Map') {
+            return new Map(value.value);
+        }
+        else if (value.__LSType === 'Set') {
+            return new Set(value.value);
+        }
+    }
+    return value;
+}
+function safeStringify(value) {
+    return JSON.stringify(value, replacer);
+}
+function safeParse(value) {
+    return JSON.parse(value, reviver);
+}
+function clone(value) {
+    return safeParse(safeStringify(value));
+}
+
 let timeout;
 let numInBatch = 0;
 let isRunningBatch = false;
@@ -219,22 +441,28 @@ function isArraySubset(mainArr, subsetArr) {
 }
 function createPreviousHandlerInner(value, changes) {
     // Clones the current state and inject the previous data at the changed path
-    let clone = value ? JSON.parse(JSON.stringify(value)) : {};
+    let cloned = value ? clone(value) : {};
     for (let i = 0; i < changes.length; i++) {
         const { path, prevAtPath } = changes[i];
-        let o = clone;
+        let o = cloned;
         if (path.length > 0) {
             let i;
             for (i = 0; i < path.length - 1; i++) {
                 o = o[path[i]];
             }
-            o[path[i]] = prevAtPath;
+            const key = path[i];
+            if (o instanceof Map) {
+                o.set(key, prevAtPath);
+            }
+            else {
+                o[key] = prevAtPath;
+            }
         }
         else {
-            clone = prevAtPath;
+            cloned = prevAtPath;
         }
     }
-    return clone;
+    return cloned;
 }
 function createPreviousHandler(value, changes) {
     // Create a function that generates the previous state
@@ -304,7 +532,7 @@ function computeChangesRecursive(changesInBatch, node, value, path, pathTypes, v
         const parent = node.parent;
         if (parent) {
             const parentValue = getNodeValue(parent);
-            computeChangesRecursive(changesInBatch, parent, parentValue, [node.key].concat(path), [(isArray(value) ? 'array' : 'object')].concat(pathTypes), valueAtPath, prevAtPath, immediate, level + 1, whenOptimizedOnlyIf);
+            computeChangesRecursive(changesInBatch, parent, parentValue, [node.key].concat(path), [getPathType(value)].concat(pathTypes), valueAtPath, prevAtPath, immediate, level + 1, whenOptimizedOnlyIf);
         }
     }
 }
@@ -1121,6 +1349,9 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
         childNode = node;
     // Make sure we don't call too many listeners for ever property set
     beginBatch();
+    if (isPrim === undefined) {
+        isPrim = isPrimitive(newValue);
+    }
     let hasADiff = isPrim;
     let whenOptimizedOnlyIf = false;
     // If new value is an object or array update notify down the tree
@@ -1195,176 +1426,6 @@ function peek(node) {
     return value;
 }
 
-function isObservable(obs) {
-    return obs && !!obs[symbolGetNode];
-}
-function isEvent(obs) {
-    var _a;
-    return obs && ((_a = obs[symbolGetNode]) === null || _a === void 0 ? void 0 : _a.isEvent);
-}
-function computeSelector(selector, e, retainObservable) {
-    let c = selector;
-    if (isFunction(c)) {
-        c = e ? c(e) : c();
-    }
-    return isObservable(c) && !retainObservable ? c.get() : c;
-}
-function getObservableIndex(obs) {
-    const node = getNode(obs);
-    const n = +node.key;
-    return n - n < 1 ? +n : -1;
-}
-function opaqueObject(value) {
-    if (value) {
-        value[symbolOpaque] = true;
-    }
-    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;
-    if (path.length > 0) {
-        for (let i = 0; i < path.length; i++) {
-            const p = path[i];
-            if (i === path.length - 1) {
-                // Don't set if the value is the same. This prevents creating a new key
-                // when setting undefined on an object without this key
-                if (o[p] !== value) {
-                    o[p] = value;
-                }
-            }
-            else if (o[p] === symbolDelete) {
-                // If this was previously deleted, restore it
-                if (oFull) {
-                    o[p] = oFull[p];
-                    restore === null || restore === void 0 ? void 0 : restore(path.slice(0, i + 1), o[p]);
-                }
-                break;
-            }
-            else if (o[p] === undefined || o[p] === null) {
-                o[p] = pathTypes[i] === 'array' ? [] : {};
-            }
-            o = o[p];
-            if (oFull) {
-                oFull = oFull[p];
-            }
-        }
-    }
-    else {
-        obj = value;
-    }
-    return obj;
-}
-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];
-    }
-    if (v === symbolDelete) {
-        o.delete();
-    }
-    // Assign if possible, or set otherwise
-    else if (mode === 'assign' && o.assign && isObject(o.peek())) {
-        o.assign(v);
-    }
-    else {
-        o.set(v);
-    }
-}
-function mergeIntoObservable(target, ...sources) {
-    beginBatch();
-    globalState.isMerging = true;
-    for (let i = 0; i < sources.length; i++) {
-        target = _mergeIntoObservable(target, sources[i]);
-    }
-    globalState.isMerging = false;
-    endBatch();
-    return target;
-}
-function _mergeIntoObservable(target, source) {
-    var _a;
-    const needsSet = isObservable(target);
-    const targetValue = needsSet ? target.peek() : target;
-    const isTargetArr = isArray(targetValue);
-    const isTargetObj = !isTargetArr && isObject(targetValue);
-    if ((isTargetObj && isObject(source) && !isEmpty(targetValue)) ||
-        (isTargetArr && isArray(source) && targetValue.length > 0)) {
-        const keys = Object.keys(source);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const sourceValue = source[key];
-            if (sourceValue === symbolDelete) {
-                needsSet && ((_a = target[key]) === null || _a === void 0 ? void 0 : _a.delete) ? target[key].delete() : delete target[key];
-            }
-            else {
-                const isObj = isObject(sourceValue);
-                const isArr = !isObj && isArray(sourceValue);
-                const targetChild = target[key];
-                if ((isObj || isArr) && targetChild && (needsSet || !isEmpty(targetChild))) {
-                    if (!needsSet && (!targetChild || (isObj ? !isObject(targetChild) : !isArray(targetChild)))) {
-                        target[key] = sourceValue;
-                    }
-                    else {
-                        _mergeIntoObservable(targetChild, sourceValue);
-                    }
-                }
-                else {
-                    needsSet
-                        ? targetChild.set(sourceValue)
-                        : (target[key] = sourceValue);
-                }
-            }
-        }
-    }
-    else if (source !== undefined) {
-        needsSet ? target.set(source) : (target = source);
-    }
-    return target;
-}
-function constructObjectWithPath(path, pathTypes, value) {
-    let out;
-    if (path.length > 0) {
-        let o = (out = {});
-        for (let i = 0; i < path.length; i++) {
-            const p = path[i];
-            o[p] = i === path.length - 1 ? value : pathTypes[i] === 'array' ? [] : {};
-            o = o[p];
-        }
-    }
-    else {
-        out = value;
-    }
-    return out;
-}
-function deconstructObjectWithPath(path, pathTypes, value) {
-    let o = value;
-    for (let i = 0; i < path.length; i++) {
-        const p = path[i];
-        o = o ? o[p] : pathTypes[i] === 'array' ? [] : {};
-    }
-    return o;
-}
-function isObservableValueReady(value) {
-    return !!value && ((!isObject(value) && !isArray(value)) || !isEmpty(value));
-}
-function setSilently(obs, newValue) {
-    const node = getNode(obs);
-    return setNodeValue(node, newValue).newValue;
-}
-
 const fns = ['get', 'set', 'peek', 'onChange', 'toggle'];
 function ObservablePrimitiveClass(node) {
     this._node = node;
@@ -1740,15 +1801,20 @@ function whenReady(predicate, effect) {
 }
 
 const internal = {
+    clone,
     ensureNodeValue,
     findIDKey,
     get,
     getNode,
+    getPathType,
     getProxy,
     globalState,
+    initializePathType,
     observableFns,
     optimized,
     peek,
+    safeParse,
+    safeStringify,
     set,
     setAtPath,
     setNodeValue,