@legendapp/state 0.9.2-alpha.7 → 0.10.0-next.0

package/esm/index.d.ts

@@ -0,0 +1,4 @@
+export { shouldRender, mergeIntoObservable, shallow } from './src/helpers';
+export { observable } from './src/observable';
+export { observableBatcher } from './src/observableBatcher';
+export * from './src/observableInterfaces';

package/esm/index.js

@@ -0,0 +1,5 @@
+export { shouldRender, mergeIntoObservable, shallow } from './src/helpers';
+export { observable } from './src/observable';
+export { observableBatcher } from './src/observableBatcher';
+export * from './src/observableInterfaces';
+//# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,cAAc,4BAA4B,CAAC"}

package/esm/internal.d.ts

@@ -0,0 +1,3 @@
+export { observableConfiguration } from './src/configureObservable';
+export { symbolShallow, symbolDateModified } from './src/globals';
+export { getDateModifiedKey } from './src/persistHelpers';

package/esm/internal.js

@@ -0,0 +1,4 @@
+export { observableConfiguration } from './src/configureObservable';
+export { symbolShallow, symbolDateModified } from './src/globals';
+export { getDateModifiedKey } from './src/persistHelpers';
+//# sourceMappingURL=internal.js.map

package/esm/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/esm/local-storage.d.ts

@@ -0,0 +1 @@
+export * from './src/persist/local-storage';

package/esm/local-storage.js

@@ -0,0 +1,2 @@
+export * from './src/persist/local-storage';
+//# sourceMappingURL=local-storage.js.map

package/esm/local-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage.js","sourceRoot":"","sources":["../../local-storage.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/esm/mmkv.d.ts

@@ -0,0 +1 @@
+export * from './src/persist/mmkv';

package/esm/mmkv.js

@@ -0,0 +1,2 @@
+export * from './src/persist/mmkv';
+//# sourceMappingURL=mmkv.js.map

package/esm/mmkv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmkv.js","sourceRoot":"","sources":["../../mmkv.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/esm/persist.d.ts

@@ -0,0 +1 @@
+export { persistObservable } from './src/persistObservable';

package/esm/persist.js

@@ -0,0 +1,2 @@
+export { persistObservable } from './src/persistObservable';
+//# sourceMappingURL=persist.js.map

package/esm/persist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist.js","sourceRoot":"","sources":["../../persist.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC"}

package/esm/react.d.ts

@@ -0,0 +1,3 @@
+export * from './src/react/useObservables';
+export * from './src/react/useNewObservable';
+export * from './src/react/useObservableArray';

package/esm/react.js

@@ -0,0 +1,4 @@
+export * from './src/react/useObservables';
+export * from './src/react/useNewObservable';
+export * from './src/react/useObservableArray';
+//# sourceMappingURL=react.js.map

package/esm/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","sourceRoot":"","sources":["../../react.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC"}

package/esm/src/configureObservable.d.ts

@@ -0,0 +1,10 @@
+import { ClassConstructor, ObservablePersistLocal, ObservablePersistRemote } from './observableInterfaces';
+interface Config {
+    persistLocal?: ClassConstructor<ObservablePersistLocal>;
+    persistRemote?: ClassConstructor<ObservablePersistRemote>;
+    saveTimeout?: number;
+    dateModifiedKey?: string;
+}
+export declare const observableConfiguration: Config;
+export declare function configureObservable(options?: Config): void;
+export {};

package/esm/src/configureObservable.js

@@ -0,0 +1,5 @@
+export const observableConfiguration = {};
+export function configureObservable(options) {
+    Object.assign(observableConfiguration, options);
+}
+//# sourceMappingURL=configureObservable.js.map

package/esm/src/configureObservable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configureObservable.js","sourceRoot":"","sources":["../../../src/configureObservable.ts"],"names":[],"mappings":"AASA,MAAM,CAAC,MAAM,uBAAuB,GAAW,EAAE,CAAC;AAElD,MAAM,UAAU,mBAAmB,CAAC,OAAgB;IAChD,MAAM,CAAC,MAAM,CAAC,uBAAuB,EAAE,OAAO,CAAC,CAAC;AACpD,CAAC"}

package/esm/src/globals.d.ts

@@ -0,0 +1,15 @@
+import { ObservableChecker, ProxyValue } from './observableInterfaces';
+export declare const delim = "\uFEFF";
+export declare const symbolDateModified: unique symbol;
+export declare const symbolShallow: unique symbol;
+export declare const symbolShouldRender: unique symbol;
+export declare const symbolID: unique symbol;
+export declare const symbolGet: unique symbol;
+export declare const symbolIsObservable: unique symbol;
+export declare function getNodeValue(node: ProxyValue): any;
+export declare function getParentNode(node: ProxyValue): {
+    parent: ProxyValue;
+    key: string | number;
+};
+export declare function getChildNode(node: ProxyValue, key: string | number): ProxyValue;
+export declare function getObservableRawValue<T>(obs: ObservableChecker<T>): T;

package/esm/src/globals.js

@@ -0,0 +1,61 @@
+import { isPrimitive } from './is';
+import { state } from './state';
+export const delim = '\uFEFF';
+export const symbolDateModified = Symbol('dateModified');
+export const symbolShallow = Symbol('shallow');
+export const symbolShouldRender = Symbol('shouldRender');
+export const symbolID = Symbol('id');
+export const symbolGet = Symbol('get');
+export const symbolIsObservable = Symbol('isObservable');
+export function getNodeValue(node) {
+    let child = node.root;
+    const arr = node.path.split(delim);
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i] !== undefined && child) {
+            child = child[arr[i]];
+        }
+    }
+    return child;
+}
+export function getParentNode(node) {
+    if (node.path === '_')
+        return { parent: node, key: undefined };
+    const parent = node.root.proxyValues.get(node.pathParent);
+    return { parent, key: node.key };
+}
+export function getChildNode(node, key) {
+    const path = node.path + delim + key;
+    let child = node.root.proxyValues.get(path);
+    if (!child) {
+        // console.log('creating child', node.path, key);
+        child = {
+            root: node.root,
+            path: node.path + delim + key,
+            // arr: node.arr.concat(key),
+            // arrParent: node.arr,
+            pathParent: node.path,
+            key,
+        };
+        node.root.proxyValues.set(path, child);
+    }
+    return child;
+}
+export function getObservableRawValue(obs) {
+    if (!obs || isPrimitive(obs))
+        return obs;
+    const eq = obs[symbolShouldRender];
+    if (eq) {
+        state.trackingShouldRender = eq.fn;
+        obs = eq.obs;
+    }
+    const shallow = obs[symbolShallow];
+    if (shallow) {
+        state.trackingShallow = true;
+        obs = shallow;
+    }
+    let ret = obs[symbolGet];
+    state.trackingShouldRender = undefined;
+    state.trackingShallow = false;
+    return ret;
+}
+//# sourceMappingURL=globals.js.map

package/esm/src/globals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.js","sourceRoot":"","sources":["../../../src/globals.ts"],"names":[],"mappings":"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"}

package/esm/src/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { ShouldRender, Observable, Shallow } from './observableInterfaces';
+export declare function shallow(obs: Observable): Shallow;
+export declare function shouldRender<T>(obs: Observable<T>, fn: (value: T, prev: T) => any): ShouldRender;
+export declare function isObservable(obs: any): boolean;
+export declare function mergeIntoObservable(target: Observable, ...sources: any[]): any;

package/esm/src/helpers.js

@@ -0,0 +1,38 @@
+import { symbolDateModified, symbolShouldRender, symbolShallow, symbolIsObservable } from './globals';
+import { isObject } from './is';
+export function shallow(obs) {
+    return {
+        [symbolShallow]: obs,
+    };
+}
+export function shouldRender(obs, fn) {
+    return {
+        [symbolShouldRender]: { obs, fn },
+    };
+}
+export function isObservable(obs) {
+    return obs && !!obs[symbolIsObservable];
+}
+export function mergeIntoObservable(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        if (source[symbolDateModified]) {
+            target.setProp(symbolDateModified, source[symbolDateModified]);
+        }
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key] || !isObject(target[key])) {
+                    target.setProp(key, {});
+                }
+                mergeIntoObservable(target[key], source[key]);
+            }
+            else {
+                target.setProp(key, source[key]);
+            }
+        }
+    }
+    return mergeIntoObservable(target, ...sources);
+}
+//# sourceMappingURL=helpers.js.map

package/esm/src/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACtG,OAAO,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAGhC,MAAM,UAAU,OAAO,CAAC,GAAe;IACnC,OAAO;QACH,CAAC,aAAa,CAAC,EAAE,GAAG;KACvB,CAAC;AACN,CAAC;AACD,MAAM,UAAU,YAAY,CAAI,GAAkB,EAAE,EAA8B;IAC9E,OAAO;QACH,CAAC,kBAAkB,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;KACpC,CAAC;AACN,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,GAAQ;IACjC,OAAO,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,kBAAyB,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAkB,EAAE,GAAG,OAAc;IACrE,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE,OAAO,MAAM,CAAC;IACnC,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAE/B,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;QACtC,IAAI,MAAM,CAAC,kBAAyB,CAAC,EAAE;YACnC,MAAM,CAAC,OAAO,CAAC,kBAAkB,EAAE,MAAM,CAAC,kBAAyB,CAAC,CAAC,CAAC;SACzE;QACD,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE;YACtB,IAAI,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;gBACvB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;oBACxC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;iBAC3B;gBACD,mBAAmB,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aACjD;iBAAM;gBACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;aACpC;SACJ;KACJ;IACD,OAAO,mBAAmB,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC;AACnD,CAAC"}

package/esm/src/is.d.ts

@@ -0,0 +1,7 @@
+export declare function isArray(obj: unknown): obj is Array<any>;
+export declare function isString(obj: unknown): obj is string;
+export declare function isObject(obj: unknown): obj is Record<any, any>;
+export declare function isFunction(obj: unknown): obj is Function;
+export declare function isPrimitive(arg: any): boolean;
+export declare function isObjectEmpty(obj: object): boolean;
+export declare function isSymbol(obj: unknown): obj is symbol;

package/esm/src/is.js

@@ -0,0 +1,23 @@
+export function isArray(obj) {
+    return Array.isArray(obj);
+}
+export function isString(obj) {
+    return typeof obj === 'string';
+}
+export function isObject(obj) {
+    return typeof obj === 'object' && obj !== null && !isArray(obj);
+}
+export function isFunction(obj) {
+    return typeof obj === 'function';
+}
+export function isPrimitive(arg) {
+    var type = typeof arg;
+    return arg == null || (type != 'object' && type != 'function');
+}
+export function isObjectEmpty(obj) {
+    return obj && isObject(obj) && Object.keys(obj).length === 0;
+}
+export function isSymbol(obj) {
+    return typeof obj === 'symbol';
+}
+//# sourceMappingURL=is.js.map

package/esm/src/is.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is.js","sourceRoot":"","sources":["../../../src/is.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,OAAO,CAAC,GAAY;IAChC,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC;AACD,MAAM,UAAU,QAAQ,CAAC,GAAY;IACjC,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC;AACnC,CAAC;AACD,MAAM,UAAU,QAAQ,CAAC,GAAY;IACjC,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;AACpE,CAAC;AACD,MAAM,UAAU,UAAU,CAAC,GAAY;IACnC,OAAO,OAAO,GAAG,KAAK,UAAU,CAAC;AACrC,CAAC;AACD,MAAM,UAAU,WAAW,CAAC,GAAG;IAC3B,IAAI,IAAI,GAAG,OAAO,GAAG,CAAC;IACtB,OAAO,GAAG,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,QAAQ,IAAI,IAAI,IAAI,UAAU,CAAC,CAAC;AACnE,CAAC;AACD,MAAM,UAAU,aAAa,CAAC,GAAW;IACrC,OAAO,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;AACjE,CAAC;AACD,MAAM,UAAU,QAAQ,CAAC,GAAY;IACjC,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC;AACnC,CAAC"}

package/esm/src/observable.d.ts

@@ -0,0 +1,6 @@
+import { Observable, ObservablePrimitive } from './observableInterfaces';
+export declare function observable<T extends object | Array<any>>(obj: T): Observable<T>;
+export declare function observable<T extends boolean>(prim: T): ObservablePrimitive<boolean>;
+export declare function observable<T extends string>(prim: T): ObservablePrimitive<string>;
+export declare function observable<T extends number>(prim: T): ObservablePrimitive<number>;
+export declare function observable<T extends boolean | string | number>(prim: T): ObservablePrimitive<T>;

package/esm/src/observable.js

@@ -0,0 +1,365 @@
+import { delim, getChildNode, getNodeValue, getParentNode, symbolGet, symbolID, symbolIsObservable } from './globals';
+import { isArray, isFunction, isPrimitive, isSymbol } from './is';
+import { observableBatcher, observableBatcherNotify } from './observableBatcher';
+import { onChange, onChangeShallow, onEquals, onHasValue, onTrue } from './on';
+import { state } from './state';
+let lastAccessedNode;
+let lastAccessedPrimitive;
+let inSetFn = false;
+const ArrayModifiers = new Set([
+    'copyWithin',
+    'fill',
+    'from',
+    'pop',
+    'push',
+    'reverse',
+    'shift',
+    'sort',
+    'splice',
+    'unshift',
+]);
+const ArrayLoopers = new Set(['every', 'some', 'filter', 'reduce', 'reduceRight', 'forEach', 'map']);
+const objectFnsProxy = new Map([
+    ['set', set],
+    ['setProp', setProp],
+    ['onChange', onChange],
+    ['onChangeShallow', onChangeShallow],
+    ['onEquals', onEquals],
+    ['onHasValue', onHasValue],
+    ['onTrue', onTrue],
+    ['prop', prop],
+    ['assign', assign],
+    ['delete', deleteFn],
+]);
+// Override primitives
+const wrapFn = (fn) => function (...args) {
+    if (lastAccessedNode && lastAccessedPrimitive) {
+        const node = getChildNode(lastAccessedNode, lastAccessedPrimitive);
+        if (getNodeValue(node) === this) {
+            return fn(node, ...args);
+        }
+    }
+};
+const toOverride = [Number, Boolean, String];
+objectFnsProxy.forEach((fn, key) => {
+    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, key } = getParentNode(node);
+        if (parent) {
+            const parentValue = getNodeValue(parent);
+            // 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, key, target);
+        }
+    }
+    // Return the original value
+    return ret;
+}
+function updateNodes(parent, obj, prevValue) {
+    const isArr = isArray(obj);
+    // If array it's faster to just use the array
+    const keys = isArr ? obj : Object.keys(obj);
+    const length = keys.length;
+    for (let i = 0; i < length; i++) {
+        const key = isArr ? i : keys[i];
+        const value = obj[key];
+        const prev = prevValue === null || prevValue === void 0 ? void 0 : prevValue[key];
+        if (!isArr && prevValue && value !== prev) {
+            const isObj = !isPrimitive(value);
+            const child = getChildNode(parent, key);
+            // If object iterate through its children
+            if (isObj) {
+                updateNodes(child, value, prev);
+            }
+            // Notify for this child if this element is different and it has listeners
+            // But do not notify child if the parent is an array - the array's listener will cover it
+            const doNotify = child.root.listenerMap.has(child.path);
+            if (doNotify) {
+                _notify(child, value, [], value, prev, 0);
+            }
+        }
+    }
+}
+function createProxy(node) {
+    const proxy = new Proxy(node, proxyHandler);
+    node.root.proxies.set(node.path, proxy);
+    return proxy;
+}
+const descriptorNotEnumerable = {
+    enumerable: false,
+    configurable: false,
+};
+const proxyHandler = {
+    get(target, p) {
+        // Return true is called by isObservable()
+        if (p === symbolIsObservable) {
+            return true;
+        }
+        const node = target;
+        const fn = objectFnsProxy.get(p);
+        // If this is an observable function, call it
+        if (fn) {
+            return (a, b, c) => fn(node, a, b, c);
+        }
+        let value = getNodeValue(node);
+        const vProp = value[p];
+        // The get() function as well as the internal obs[symbolGet]
+        if (p === symbolGet || p === 'get') {
+            // Primitives are { current } so return the current value
+            if (node.root.isPrimitive) {
+                value = value.current;
+            }
+            // Update that this node was accessed for useObservables and useComputed
+            if (state.isTracking) {
+                state.updateTracking(node, value);
+            }
+            return p === 'get' ? () => value : value;
+        }
+        // Accessing symbols passes straight through
+        if (isSymbol(p)) {
+            return vProp;
+        }
+        // Handle function calls
+        if (isFunction(vProp)) {
+            if (isArray(value)) {
+                if (ArrayModifiers.has(p)) {
+                    // Call the wrapped modifier function
+                    return (...args) => collectionSetter(node, value, p, ...args);
+                }
+                else if (ArrayLoopers.has(p)) {
+                    // Bind this looping function to an array of proxies
+                    const arr = [];
+                    for (let i = 0; i < value.length; i++) {
+                        arr.push(prop(node, i));
+                    }
+                    return vProp.bind(arr);
+                }
+            }
+            // Return the function bound to the value
+            return vProp.bind(value);
+        }
+        // Accessing primitives tracks and returns
+        if (isPrimitive(vProp)) {
+            // Accessing a primitive saves the last accessed so that the observable functions
+            // bound to primitives can know which node was accessed
+            lastAccessedNode = node;
+            lastAccessedPrimitive = p;
+            // Update that this node was accessed for useObservables and useComputed
+            if (state.isTracking) {
+                state.updateTracking(getChildNode(node, p), value);
+            }
+            return vProp;
+        }
+        // Create a proxy if not already cached and return it
+        const path = target.path + delim + p;
+        let proxy = node.root.proxies.get(path);
+        if (!proxy) {
+            proxy = createProxy(getChildNode(target, p));
+        }
+        return proxy;
+    },
+    // Forward all proxy properties to the target's value
+    getPrototypeOf(target) {
+        const value = getNodeValue(target);
+        return Reflect.getPrototypeOf(value);
+    },
+    ownKeys(target) {
+        const value = getNodeValue(target);
+        const keys = Reflect.ownKeys(value);
+        if (isArray(value)) {
+            if (keys[keys.length - 1] === 'length') {
+                keys.splice(keys.length - 1, 1);
+            }
+        }
+        return keys;
+    },
+    getOwnPropertyDescriptor(target, p) {
+        if (p === symbolID) {
+            return descriptorNotEnumerable;
+        }
+        const value = getNodeValue(target);
+        return Reflect.getOwnPropertyDescriptor(value, p);
+    },
+    set(target, prop, value) {
+        // If this assignment comes from within an observable function it's allowed
+        if (inSetFn) {
+            Reflect.set(target, prop, value);
+            return true;
+        }
+        else {
+            return false;
+        }
+    },
+    deleteProperty(target, prop) {
+        // If this delete comes from within an observable function it's allowed
+        if (inSetFn) {
+            Reflect.deleteProperty(target, prop);
+            return true;
+        }
+        else {
+            return false;
+        }
+    },
+    has(target, prop) {
+        const value = getNodeValue(target);
+        return Reflect.has(value, prop);
+    },
+};
+function set(node, newValue) {
+    if (node.root.isPrimitive) {
+        return setProp(node, 'current', newValue);
+    }
+    else {
+        const { parent, key } = getParentNode(node);
+        return setProp(parent, key, newValue);
+    }
+}
+function setProp(node, key, newValue) {
+    var _a;
+    newValue = (_a = newValue === null || newValue === void 0 ? void 0 : newValue[symbolGet]) !== null && _a !== void 0 ? _a : newValue;
+    const isPrim = isPrimitive(newValue);
+    if (!key && !node.path.includes(delim)) {
+        return assign(node, newValue);
+    }
+    inSetFn = true;
+    // Get the child node for updating and notifying
+    const childNode = getChildNode(node, key);
+    // Get the value of the parent
+    let parentValue = getNodeValue(node);
+    // Save the previous value first
+    const prevValue = parentValue[key];
+    // Save the new value
+    parentValue[key] = newValue;
+    // If new value is an object or array update notify down the tree
+    if (!isPrim) {
+        updateNodes(childNode, newValue, prevValue);
+    }
+    // Notify for this element if it's an object or it's changed
+    if (!isPrim || newValue !== prevValue) {
+        notify(node.root.isPrimitive ? node : childNode, newValue, prevValue, prevValue === undefined ? -1 : 0);
+    }
+    inSetFn = false;
+    return newValue;
+}
+function _notify(node, value, path, valueAtPath, prevAtPath, level) {
+    const listeners = node.root.listenerMap.get(node.path);
+    // Notify all listeners
+    if (listeners) {
+        let getPrevious;
+        for (let listener of listeners) {
+            // Notify if listener is not shallow or if this is the first level
+            if (!listener.shallow || level <= 0) {
+                // Create a function to get the previous data. Computing a clone of previous data can be expensive if doing
+                // it often, so leave it up to the user.
+                if (!getPrevious) {
+                    getPrevious = createPreviousHandler(value, path, prevAtPath);
+                }
+                observableBatcherNotify({ cb: listener.callback, value, getPrevious, path, valueAtPath, prevAtPath });
+            }
+        }
+    }
+}
+function createPreviousHandler(value, path, prevAtPath) {
+    // Create a function that clones the current state and injects the previous data at the changed path
+    return function () {
+        let clone = value ? JSON.parse(JSON.stringify(value)) : path.length > 0 ? {} : value;
+        let o = clone;
+        if (path.length > 0) {
+            let i;
+            for (i = 0; i < path.length - 1; i++) {
+                o = o[path[i]];
+            }
+            o[path[i]] = prevAtPath;
+        }
+        else {
+            clone = prevAtPath;
+        }
+        return clone;
+    };
+}
+function _notifyParents(node, value, path, valueAtPath, prevAtPath, level) {
+    // Do the notify
+    _notify(node, value, path, valueAtPath, prevAtPath, level);
+    // If not root notify up through parents
+    if (node.path !== '_') {
+        const { parent, key } = getParentNode(node);
+        if (parent) {
+            const parentValue = getNodeValue(parent);
+            _notifyParents(parent, parentValue, [key].concat(path), valueAtPath, prevAtPath, level + 1);
+        }
+    }
+}
+function notify(node, value, prev, level) {
+    // Start notifying up through parents with the listenerInfo
+    _notifyParents(node, value, [], value, prev, level);
+}
+function prop(node, key) {
+    const child = getChildNode(node, key);
+    return createProxy(child);
+}
+function assign(node, value) {
+    observableBatcher.begin();
+    // Assign calls set with all assigned properties
+    const keys = Object.keys(value);
+    const length = keys.length;
+    for (let i = 0; i < length; i++) {
+        setProp(node, keys[i], value[keys[i]]);
+    }
+    const ret = getNodeValue(node);
+    observableBatcher.end();
+    return ret;
+}
+function deleteFn(node, key) {
+    // If called without a key, delete by key from the parent node
+    if (key !== undefined) {
+        return deleteFnByKey(node, key);
+    }
+    else {
+        const { parent, key } = getParentNode(node);
+        return deleteFnByKey(parent, key);
+    }
+}
+function deleteFnByKey(node, key) {
+    if (!node.root.isPrimitive) {
+        // delete sets to undefined first to cleanup children
+        setProp(node, key, undefined);
+    }
+    inSetFn = true;
+    // Then delete the key from the object
+    let child = getNodeValue(node);
+    delete child[key];
+    inSetFn = false;
+}
+export function observable(obj) {
+    const isPrim = isPrimitive(obj);
+    // Primitives wrap in current
+    if (isPrim) {
+        obj = { current: obj };
+    }
+    const obs = {
+        _: obj,
+        isPrimitive: isPrim,
+        listenerMap: new Map(),
+        proxies: new Map(),
+        proxyValues: new Map(),
+    };
+    const node = {
+        root: obs,
+        path: '_',
+        pathParent: '',
+        key: '_',
+    };
+    obs.proxyValues.set(node.path, node);
+    updateNodes(node, obs._);
+    const proxy = createProxy(node);
+    // @ts-ignore
+    return proxy;
+}
+//# sourceMappingURL=observable.js.map