j-templates 6.0.0 → 6.0.2

package/DOM/createPropertyAssignment.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateNodeValueAssignment = CreateNodeValueAssignment;
 exports.CreatePropertyAssignment = CreatePropertyAssignment;
-const json_1 = require("../Utils/json");
+const jsonType_1 = require("../Utils/jsonType");
 function AssignProp(target, prop) {
     let lastValue = target[prop];
     return function Assign(value) {
@@ -43,7 +43,7 @@ function ValueAssignment(target, writeTo, next) {
 }
 function DefaultAssignment(target, writeTo, next, prop) {
     const value = next[prop];
-    writeTo[prop] ??= (0, json_1.JsonType)(value) === 'value' ?
+    writeTo[prop] ??= (0, jsonType_1.JsonType)(value) === 'value' ?
         AssignProp(target, prop) :
         CreatePropertyAssignment(target[prop], false);
     writeTo[prop](value);

package/Node/nodeRef.types.d.ts

@@ -16,4 +16,4 @@ export interface INodeRefBase {
 export interface INodeRef extends INodeRefBase {
     type: NodeRefType.NodeRef;
 }
-export type NodeRefTypes = INodeRef | IBoundNode | IElementNode<unknown> | IComponentNode<unknown, unknown, unknown>;
+export type NodeRefTypes = INodeRef | IBoundNode | IElementNode<any> | IComponentNode<any, any, any>;

package/Store/Diff/diffSync.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiffSync = void 0;
+const json_1 = require("../../Utils/json");
 const jsonDeepClone_1 = require("../../Utils/jsonDeepClone");
 const diffTree_1 = require("./diffTree");
-const diffCnstr = (0, diffTree_1.DiffTreeFactory)();
+const diffCnstr = (0, diffTree_1.DiffTreeFactory)(json_1.JsonDiffFactory);
 class DiffSync {
     diffTree;
     constructor(keyFunc) {

package/Store/Diff/diffTree.js

@@ -115,7 +115,7 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
     }
     class DiffTree {
         keyFunc;
-        rootState = { root: null };
+        rootState = {};
         constructor(keyFunc) {
             this.keyFunc = keyFunc;
         }
@@ -126,11 +126,9 @@ function DiffTreeFactory(jsonDiffFactory, worker) {
             return results;
         }
         DiffPath(path, value) {
-            path = (path && `root.${path}`) || "root";
             return UpdateSource(this.rootState, path, value, this.keyFunc);
         }
         GetPath(path) {
-            path = (path && `root.${path}`) || "root";
             return GetPathValue(this.rootState, path);
         }
     }

package/Store/Diff/workerQueue.js

@@ -9,11 +9,11 @@ class WorkerQueue {
         this.worker = worker;
         this.callbacks = list_1.List.Create();
         this.worker.onerror = (err) => {
-            var cb = list_1.List.Pop(this.callbacks);
+            const cb = list_1.List.Pop(this.callbacks);
             cb && cb(null, err);
         };
         this.worker.onmessage = (message) => {
-            var cb = list_1.List.Pop(this.callbacks);
+            const cb = list_1.List.Pop(this.callbacks);
             cb && cb(message.data);
         };
     }

package/Store/Store/store.d.ts

@@ -0,0 +1,10 @@
+import { JsonDiffResult } from "../../Utils/json";
+export declare class Store {
+    protected keyFunc: (value: unknown) => string;
+    private rootMap;
+    private createNode;
+    constructor(keyFunc: (value: unknown) => string);
+    Get<O>(id: string, defaultValue?: O): O | undefined;
+    protected UpdateRootMap(results: JsonDiffResult): void;
+    private UpdateRootObject;
+}

package/Store/Store/store.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
+const json_1 = require("../../Utils/json");
+const observableNode_1 = require("../Tree/observableNode");
+class Store {
+    keyFunc;
+    rootMap = new Map();
+    createNode;
+    constructor(keyFunc) {
+        this.keyFunc = keyFunc;
+        const aliasFunc = (value) => {
+            const key = keyFunc(value);
+            if (key === undefined)
+                return undefined;
+            const rootObject = this.rootMap.get(key);
+            if (rootObject === undefined)
+                throw `No root object found for key: ${key}`;
+            const rootValue = rootObject[observableNode_1.GET_OBSERVABLE_VALUE];
+            const alias = rootValue[key];
+            return alias;
+        };
+        this.createNode = observableNode_1.ObservableNode.CreateFactory(aliasFunc);
+    }
+    Get(id, defaultValue) {
+        let result = this.rootMap.get(id);
+        if (result === undefined) {
+            result = this.createNode({ [id]: defaultValue });
+            this.rootMap.set(id, result);
+        }
+        return result[id];
+    }
+    UpdateRootMap(results) {
+        for (let x = 0; x < results.length;) {
+            const root = results[x].path[0];
+            const startIndex = x;
+            while (x < results.length && results[x].path[0] === root)
+                x++;
+            const rootGroup = results.slice(startIndex, x);
+            this.UpdateRootObject(rootGroup[0].path[0], rootGroup);
+        }
+    }
+    UpdateRootObject(rootPath, results) {
+        const rootObject = this.rootMap.get(rootPath);
+        if (rootObject === undefined) {
+            if (results.length > 1 || results[0].path.length > 1)
+                throw `Unable to initialize root path ${rootPath} with ${results.length} results and initial path ${results[0].path}`;
+            const newRootObject = this.createNode({ [rootPath]: results[0].value });
+            this.rootMap.set(rootPath, newRootObject);
+            return;
+        }
+        observableNode_1.ObservableNode.EnableDiff(true);
+        (0, json_1.ApplyDiff)(rootObject, results);
+        observableNode_1.ObservableNode.EnableDiff(false);
+    }
+}
+exports.Store = Store;

package/Store/Store/storeAsync.d.ts

@@ -0,0 +1,11 @@
+import { Store } from "./store";
+export declare class StoreAsync extends Store {
+    private diff;
+    private queue;
+    constructor(keyFunc: (value: unknown) => string);
+    Write(data: unknown, key?: string): Promise<void>;
+    Patch(key: string, patch: unknown): Promise<void>;
+    Push(key: string, ...data: unknown[]): Promise<void>;
+    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): Promise<any[]>;
+    Destroy(): void;
+}

package/Store/Store/storeAsync.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreAsync = void 0;
+const asyncQueue_1 = require("../../Utils/asyncQueue");
+const jsonMerge_1 = require("../../Utils/jsonMerge");
+const diffAsync_1 = require("../Diff/diffAsync");
+const observableNode_1 = require("../Tree/observableNode");
+const store_1 = require("./store");
+class StoreAsync extends store_1.Store {
+    diff;
+    queue = new asyncQueue_1.AsyncQueue();
+    constructor(keyFunc) {
+        super(keyFunc);
+        this.diff = new diffAsync_1.DiffAsync(keyFunc);
+    }
+    async Write(data, key) {
+        await this.queue.Next(async () => {
+            key = key || this.keyFunc(data);
+            if (!key)
+                throw "No key provided for data";
+            const diffResult = await this.diff.DiffPath(key, data);
+            this.UpdateRootMap(diffResult);
+        });
+    }
+    async Patch(key, patch) {
+        await this.queue.Next(async () => {
+            const value = this.Get(key);
+            if (value === undefined)
+                throw "Unable to patch undefined value";
+            const json = value.toJSON();
+            const mergedJson = (0, jsonMerge_1.JsonMerge)(json, patch);
+            const diffResult = await this.diff.DiffPath(key, mergedJson);
+            this.UpdateRootMap(diffResult);
+        });
+    }
+    async Push(key, ...data) {
+        await this.queue.Next(async () => {
+            const arr = this.Get(key);
+            const batch = data.map(function (d, i) {
+                return {
+                    path: `${key}.${arr.length + i}`,
+                    value: d
+                };
+            });
+            const diffResult = await this.diff.DiffBatch(batch);
+            this.UpdateRootMap(diffResult);
+        });
+    }
+    async Splice(key, start, deleteCount, ...items) {
+        return await this.queue.Next(async () => {
+            const arr = this.Get(key);
+            const arrValue = arr[observableNode_1.GET_OBSERVABLE_VALUE];
+            const arrCopy = arrValue.slice();
+            const spliceResult = arrCopy.splice(start, deleteCount, ...items);
+            const diffResult = await this.diff.DiffPath(key, arrCopy);
+            this.UpdateRootMap(diffResult);
+            return spliceResult;
+        });
+    }
+    Destroy() {
+        this.queue.Stop();
+        this.diff.Destroy();
+    }
+}
+exports.StoreAsync = StoreAsync;

package/Store/Store/storeSync.d.ts

@@ -0,0 +1,9 @@
+import { Store } from "./store";
+export declare class StoreSync extends Store {
+    private diff;
+    constructor(keyFunc: (value: unknown) => string);
+    Write(data: unknown, key?: string): void;
+    Patch(key: string, patch: unknown): void;
+    Push(key: string, ...data: unknown[]): void;
+    Splice(key: string, start: number, deleteCount?: number, ...items: unknown[]): any[];
+}

package/Store/Store/storeSync.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreSync = void 0;
+const jsonMerge_1 = require("../../Utils/jsonMerge");
+const diffSync_1 = require("../Diff/diffSync");
+const observableNode_1 = require("../Tree/observableNode");
+const store_1 = require("./store");
+class StoreSync extends store_1.Store {
+    diff;
+    constructor(keyFunc) {
+        super(keyFunc);
+        this.diff = new diffSync_1.DiffSync(keyFunc);
+    }
+    Write(data, key) {
+        key = key || this.keyFunc(data);
+        if (!key)
+            throw "No key provided for data";
+        const diffResult = this.diff.DiffPath(key, data);
+        this.UpdateRootMap(diffResult);
+    }
+    Patch(key, patch) {
+        const value = this.Get(key);
+        if (value === undefined)
+            throw "Unable to patch undefined value";
+        const json = value.toJSON();
+        const mergedJson = (0, jsonMerge_1.JsonMerge)(json, patch);
+        const diffResult = this.diff.DiffPath(key, mergedJson);
+        this.UpdateRootMap(diffResult);
+    }
+    Push(key, ...data) {
+        const arr = this.Get(key);
+        const batch = data.map(function (d, i) {
+            return {
+                path: `${key}.${arr.length + i}`,
+                value: d
+            };
+        });
+        const diffResult = this.diff.DiffBatch(batch);
+        this.UpdateRootMap(diffResult);
+    }
+    Splice(key, start, deleteCount, ...items) {
+        const arr = this.Get(key);
+        const arrValue = arr[observableNode_1.GET_OBSERVABLE_VALUE];
+        const arrCopy = arrValue.slice();
+        const spliceResult = arrCopy.splice(start, deleteCount, ...items);
+        const diffResult = this.diff.DiffPath(key, arrCopy);
+        this.UpdateRootMap(diffResult);
+        return spliceResult;
+    }
+}
+exports.StoreSync = StoreSync;

package/Store/Tree/observableNode.d.ts

@@ -1,3 +1,6 @@
+export declare const IS_OBSERVABLE_NODE = "____isObservableNode";
+export declare const GET_OBSERVABLE_VALUE = "____getObservableValue";
+export declare const GET_TO_JSON = "toJSON";
 export declare namespace ObservableNode {
     function Create<T>(value: T): T;
     function EnableDiff(value: boolean): void;

package/Store/Tree/observableNode.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableNode = void 0;
+exports.ObservableNode = exports.GET_TO_JSON = exports.GET_OBSERVABLE_VALUE = exports.IS_OBSERVABLE_NODE = void 0;
 const json_1 = require("../../Utils/json");
+const jsonType_1 = require("../../Utils/jsonType");
 const observableScope_1 = require("./observableScope");
-const IS_OBSERVABLE_NODE = "____observableNode";
+exports.IS_OBSERVABLE_NODE = "____isObservableNode";
+exports.GET_OBSERVABLE_VALUE = "____getObservableValue";
+exports.GET_TO_JSON = "toJSON";
 const proxyCache = new WeakMap();
 const scopeCache = new WeakMap();
 function getOwnPropertyDescriptor(target, prop) {
@@ -33,11 +36,11 @@ function ownKeysArray(value) {
     return Object.keys(value);
 }
 function UnwrapProxy(value) {
-    const type = (0, json_1.JsonType)(value);
+    const type = (0, jsonType_1.JsonType)(value);
     if (type === "value")
         return value;
-    if (value[IS_OBSERVABLE_NODE] === true)
-        return value.toJSON();
+    if (value[exports.IS_OBSERVABLE_NODE] === true)
+        return value[exports.GET_OBSERVABLE_VALUE];
     switch (type) {
         case "object": {
             const keys = Object.keys(value);
@@ -53,17 +56,23 @@ function UnwrapProxy(value) {
 }
 let applyingDiff = false;
 function CreateProxyFactory(alias) {
+    function CreateProxy(value) {
+        value = UnwrapProxy(value);
+        return CreateProxyFromValue(value);
+    }
     function ToJsonCopy(value) {
-        const type = (0, json_1.JsonType)(value);
+        const type = (0, jsonType_1.JsonType)(value);
         switch (type) {
             case "array": {
                 const typedValue = value;
-                return typedValue.map(ToJsonCopy);
+                const proxy = CreateProxy(typedValue);
+                return proxy.map(ToJsonCopy);
                 break;
             }
             case "object": {
                 const typedValue = alias(value) ?? value;
-                const keys = Object.keys(typedValue);
+                const proxy = CreateProxy(typedValue);
+                const keys = Object.keys(proxy);
                 const copy = {};
                 for (let x = 0; x < keys.length; x++)
                     copy[keys[x]] = ToJsonCopy(typedValue[keys[x]]);
@@ -77,6 +86,7 @@ function CreateProxyFactory(alias) {
         return value;
     }
     const ToJson = alias !== undefined ? ToJsonCopy : ToJsonDefault;
+    const readOnly = alias !== undefined;
     function CreateArrayProxy(value) {
         const scope = observableScope_1.ObservableScope.Create(() => value);
         const proxy = new Proxy(value, {
@@ -104,8 +114,10 @@ function CreateProxyFactory(alias) {
         return proxy;
     }
     function ArrayProxySetter(array, prop, value) {
-        if (prop === IS_OBSERVABLE_NODE)
-            throw `Cannot assign read-only property: ${IS_OBSERVABLE_NODE}`;
+        if (readOnly && !applyingDiff)
+            throw `Object is readonly`;
+        if (prop === exports.IS_OBSERVABLE_NODE)
+            throw `Cannot assign read-only property: ${exports.IS_OBSERVABLE_NODE}`;
         value = UnwrapProxy(value);
         array[prop] = value;
         const scope = scopeCache.get(array);
@@ -113,15 +125,29 @@ function CreateProxyFactory(alias) {
         return true;
     }
     function ArrayProxyGetter(array, prop) {
-        if (prop === IS_OBSERVABLE_NODE)
+        if (prop === exports.IS_OBSERVABLE_NODE)
             return true;
+        if (readOnly && !applyingDiff)
+            switch (prop) {
+                case "push":
+                case "unshift":
+                case "splice":
+                case "pop":
+                case "shift":
+                case "sort":
+                case "reverse":
+                    if (readOnly && !applyingDiff)
+                        throw `Object is readonly`;
+            }
         const scope = scopeCache.get(array);
         array = observableScope_1.ObservableScope.Value(scope);
         switch (prop) {
-            case "toJSON":
+            case exports.GET_TO_JSON:
                 return function () {
                     return ToJson(array);
                 };
+            case exports.GET_OBSERVABLE_VALUE:
+                return array;
             default: {
                 const arrayValue = array[prop];
                 if (typeof prop === "symbol")
@@ -156,8 +182,10 @@ function CreateProxyFactory(alias) {
         }
     }
     function ObjectProxySetter(object, prop, value) {
-        if (prop === IS_OBSERVABLE_NODE)
-            throw `Cannot assign read-only property: ${IS_OBSERVABLE_NODE}`;
+        if (readOnly && !applyingDiff)
+            throw `Object is readonly`;
+        if (prop === exports.IS_OBSERVABLE_NODE)
+            throw `Cannot assign read-only property: ${exports.IS_OBSERVABLE_NODE}`;
         const scope = scopeCache.get(object);
         value = UnwrapProxy(value);
         if (applyingDiff) {
@@ -187,15 +215,17 @@ function CreateProxyFactory(alias) {
         return true;
     }
     function ObjectProxyGetter(object, prop) {
-        if (prop === IS_OBSERVABLE_NODE)
+        if (prop === exports.IS_OBSERVABLE_NODE)
             return true;
         const scope = scopeCache.get(object);
         object = observableScope_1.ObservableScope.Value(scope);
         switch (prop) {
-            case "toJSON":
+            case exports.GET_TO_JSON:
                 return function () {
                     return ToJson(object);
                 };
+            case exports.GET_OBSERVABLE_VALUE:
+                return object;
             default: {
                 const proxyValue = object[prop];
                 if (typeof prop === "symbol")
@@ -206,7 +236,7 @@ function CreateProxyFactory(alias) {
         }
     }
     function CreateProxyFromValue(value) {
-        const type = (0, json_1.JsonType)(value);
+        const type = (0, jsonType_1.JsonType)(value);
         switch (type) {
             case "object": {
                 let proxy = proxyCache.get(value) ?? CreateObjectProxy(value);
@@ -226,10 +256,6 @@ function CreateProxyFactory(alias) {
                 return value;
         }
     }
-    function CreateProxy(value) {
-        value = UnwrapProxy(value);
-        return CreateProxyFromValue(value);
-    }
     return CreateProxy;
 }
 const DefaultCreateProxy = CreateProxyFactory();

package/Store/Tree/observableScope.d.ts

@@ -32,15 +32,14 @@ export interface IObservableScope<T> extends IDestroyable {
     value: T;
     dirty: boolean;
     emitter: Emitter;
-    emitters: Set<Emitter>;
+    emitters: (Emitter | null)[];
     setCallback: EmitterCallback;
     destroyed: boolean;
-    dependencies?: IObservableScope<unknown>[];
 }
 export declare namespace ObservableScope {
     function Create<T>(valueFunction: {
         (): T | Promise<T>;
-    } | T, dependencies?: IObservableScope<unknown>[]): IObservableScope<T>;
+    } | T): IObservableScope<T>;
     function Register(emitter: Emitter): void;
     function Value<T>(scope: IObservableScope<T>): T;
     function Watching(): boolean;

package/Store/Tree/observableScope.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableScope = exports.ObservableScopeWrapper = exports.ObservableScopeValue = void 0;
+const array_1 = require("../../Utils/array");
 const emitter_1 = require("../../Utils/emitter");
 class ObservableScopeValue {
     scope;
@@ -61,7 +62,7 @@ function WatchAction(action) {
     return lastSet;
 }
 (function (ObservableScope) {
-    function Create(valueFunction, dependencies) {
+    function Create(valueFunction) {
         const hasFunction = typeof valueFunction === "function";
         const scope = {
             getFunction: hasFunction ? valueFunction : null,
@@ -71,14 +72,13 @@ function WatchAction(action) {
                 : false,
             dirty: hasFunction,
             emitter: hasFunction ? emitter_1.Emitter.Create() : null,
-            emitters: null,
+            emitters: [],
             destroyed: false,
             setCallback: hasFunction
                 ? function () {
                     return OnSet(scope);
                 }
                 : null,
-            dependencies,
         };
         return scope;
     }
@@ -154,23 +154,30 @@ function UpdateValue(scope) {
 function DestroyScope(scope) {
     if (!scope)
         return;
-    if (scope.dependencies !== undefined)
-        for (let x = 0; x < scope.dependencies.length; x++)
-            DestroyScope(scope.dependencies[x]);
-    scope.emitters && scope.emitters.clear();
-    scope.emitter && emitter_1.Emitter.Clear(scope.emitter);
+    scope.emitters = null;
+    scope.emitter = null;
     scope.getFunction = null;
     scope.setCallback = null;
     scope.destroyed = true;
 }
 function UpdateEmitters(scope, newEmitters) {
-    if (newEmitters) {
-        newEmitters.forEach((e) => {
-            if (!scope.emitters?.delete(e))
-                emitter_1.Emitter.On(e, scope.setCallback);
-        });
+    if (newEmitters === null) {
+        for (let x = 0; x < scope.emitters.length; x++)
+            emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+        scope.emitters = [];
+        return;
+    }
+    let removed = false;
+    for (let x = 0; x < scope.emitters.length; x++) {
+        if (!newEmitters.delete(scope.emitters[x])) {
+            emitter_1.Emitter.Remove(scope.emitters[x], scope.setCallback);
+            scope.emitters[x] = null;
+            removed = true;
+        }
     }
-    if (scope.emitters)
-        scope.emitters.forEach((e) => emitter_1.Emitter.Remove(e, scope.setCallback));
-    scope.emitters = newEmitters;
+    const initLength = scope.emitters.length;
+    scope.emitters.push(...newEmitters);
+    for (let x = initLength; x < scope.emitters.length; x++)
+        emitter_1.Emitter.On(scope.emitters[x], scope.setCallback);
+    removed && (0, array_1.RemoveNulls)(scope.emitters);
 }

package/Store/index.d.ts

@@ -1,2 +1,4 @@
+export { StoreSync } from "./Store/storeSync";
+export { StoreAsync } from "./Store/storeAsync";
 export { ObservableScope } from "./Tree/observableScope";
 export { ObservableNode } from "./Tree/observableNode";

package/Store/index.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObservableNode = exports.ObservableScope = void 0;
+exports.ObservableNode = exports.ObservableScope = exports.StoreAsync = exports.StoreSync = void 0;
+var storeSync_1 = require("./Store/storeSync");
+Object.defineProperty(exports, "StoreSync", { enumerable: true, get: function () { return storeSync_1.StoreSync; } });
+var storeAsync_1 = require("./Store/storeAsync");
+Object.defineProperty(exports, "StoreAsync", { enumerable: true, get: function () { return storeAsync_1.StoreAsync; } });
 var observableScope_1 = require("./Tree/observableScope");
 Object.defineProperty(exports, "ObservableScope", { enumerable: true, get: function () { return observableScope_1.ObservableScope; } });
 var observableNode_1 = require("./Tree/observableNode");

package/Utils/array.js

@@ -5,11 +5,12 @@ function RemoveNulls(array, startIndex = 0) {
     let nullIndex = startIndex;
     for (; nullIndex < array.length && array[nullIndex] !== null; nullIndex++) { }
     let notNullIndex = nullIndex + 1;
+    for (; notNullIndex < array.length && array[notNullIndex] === null; notNullIndex++) { }
     while (notNullIndex < array.length) {
-        for (; notNullIndex < array.length && array[notNullIndex] === null; notNullIndex++) { }
         array[nullIndex] = array[notNullIndex];
         nullIndex++;
         notNullIndex++;
+        for (; notNullIndex < array.length && array[notNullIndex] === null; notNullIndex++) { }
     }
     array.splice(nullIndex);
 }

package/Utils/decorators.js

@@ -11,8 +11,7 @@ exports.PreReqTemplate = PreReqTemplate;
 exports.PreReq = PreReq;
 const observableScope_1 = require("../Store/Tree/observableScope");
 const observableNode_1 = require("../Store/Tree/observableNode");
-const diffAsync_1 = require("../Store/Diff/diffAsync");
-const json_1 = require("./json");
+const Store_1 = require("../Store");
 const decoratorInstanceMap = new WeakMap();
 const valueInstanceMap = new WeakMap();
 function GetDecoratorMapForInstance(instance) {
@@ -66,8 +65,6 @@ function ValueDecorator(target, propertyKey) {
         },
         set: function (val) {
             const valueMap = GetValueMapForInstance(this);
-            if (valueMap.get(propKey) === val)
-                return;
             valueMap.set(propKey, val);
             const map = GetDecoratorMapForInstance(this);
             let scope = map.get(propKey);
@@ -82,42 +79,28 @@ function ValueDecorator(target, propertyKey) {
         },
     };
 }
+function defaultKeyFunc() { }
 function StateAsync(defaultValue, keyFunc) {
-    return StateAsyncDecorator.bind(null, defaultValue, keyFunc);
+    return StateAsyncDecorator.bind(null, defaultValue, keyFunc ?? defaultKeyFunc);
 }
 function StateAsyncDecorator(defaultValue, keyFunc, target, propertyKey) {
     const propKey = `ValueDecorator_${propertyKey}`;
-    const treeKey = `ValueDecoratorTree_${propertyKey}`;
     return {
         configurable: false,
         enumerable: true,
         get: function () {
             const map = GetDecoratorMapForInstance(this);
-            const node = map.get(propKey);
-            return node?.root;
+            const store = map.get(propKey);
+            return store?.Get('root', defaultValue) ?? defaultValue;
         },
         set: function (val) {
             const map = GetDecoratorMapForInstance(this);
-            const node = map.get(propKey);
-            if (!node) {
-                const newNode = observableNode_1.ObservableNode.Create({ root: defaultValue });
-                map.set(propKey, newNode);
-                const newTree = new diffAsync_1.DiffAsync(keyFunc);
-                map.set(treeKey, newTree);
-                newTree.DiffPath("", val).then((result) => {
-                    observableNode_1.ObservableNode.EnableDiff(false);
-                    (0, json_1.ApplyDiff)(newNode, result);
-                    observableNode_1.ObservableNode.EnableDiff(true);
-                });
-            }
-            else {
-                const tree = map.get(treeKey);
-                tree.DiffPath("", val).then((result) => {
-                    observableNode_1.ObservableNode.EnableDiff(false);
-                    (0, json_1.ApplyDiff)(node, result);
-                    observableNode_1.ObservableNode.EnableDiff(true);
-                });
+            let store = map.get(propKey);
+            if (store === undefined) {
+                store = new Store_1.StoreAsync(keyFunc);
+                map.set(propKey, store);
             }
+            store.Write(val, "root");
         },
     };
 }

package/Utils/json.d.ts

@@ -5,8 +5,7 @@ export type JsonDiffResult<T = unknown> = {
 export type JsonDiffFactoryResult = ReturnType<typeof JsonDiffFactory>;
 export declare function ApplyDiff(root: any, diffResult: JsonDiffResult): void;
 export declare function JsonDiffFactory(): {
-    JsonType: (value: any) => "value" | "array" | "object";
     JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>;
+    JsonType: (value: any) => "value" | "array" | "object";
 };
-export declare const JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>;
-export declare const JsonType: (value: any) => "value" | "array" | "object";
+export declare const JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>, JsonType: (value: any) => "value" | "array" | "object";