j-templates 5.0.36 → 5.0.38

package/Store/Store/store.js

@@ -14,8 +14,8 @@ class Store {
         return this.rootScope;
     }
     Action(action) {
-        var node = this.observableTree.GetNode("ROOT");
-        action(node.Proxy, this.storeWriter);
+        var proxy = this.observableTree.Get("ROOT");
+        action(proxy, this.storeWriter);
     }
     Write(data) {
         this.Action((root, writer) => writer.Write(root, data));
@@ -25,7 +25,6 @@ class Store {
     }
     Destroy() {
         this.rootScope.Destroy();
-        this.observableTree.Destroy();
     }
 }
 exports.Store = Store;

package/Store/Store/storeAsync.d.ts

@@ -10,7 +10,7 @@ export declare class StoreAsync {
     }, init?: any);
     Scope<T, R>(id: string, func: {
         (val: T): R;
-    }): import("..").ObservableScope<R>;
+    }): import("..").ObservableScope<T | R>;
     Action<T>(id: string, action: {
         (val: T, writer: StoreAsyncWriter): Promise<void>;
     }): Promise<void>;

package/Store/Store/storeAsync.js

@@ -22,10 +22,7 @@ class StoreAsync {
     }
     async Action(id, action) {
         await this.asyncQueue.Next(async () => {
-            var node;
-            if (id)
-                node = this.observableTree.GetNode(id);
-            await action(node && node.Proxy, this.asyncWriter);
+            await action(id && this.observableTree.Get(id), this.asyncWriter);
         });
     }
     async Write(data) {
@@ -41,7 +38,6 @@ class StoreAsync {
     Destroy() {
         this.asyncQueue.Stop();
         this.diffAsync.Destroy();
-        this.observableTree.Destroy();
     }
 }
 exports.StoreAsync = StoreAsync;

package/Store/Store/storeAsyncWriter.d.ts

@@ -1,6 +1,5 @@
 import { DiffAsync } from "../Diff/diffAsync";
 import { ObservableTree } from "../Tree/observableTree";
-import { ObservableProxy } from "../Tree/observableProxy";
 export declare class StoreAsyncWriter {
     private idFunc;
     private diffAsync;
@@ -8,9 +7,9 @@ export declare class StoreAsyncWriter {
     constructor(idFunc: {
         (val: any): string;
     }, diffAsync: DiffAsync, observableTree: ObservableTree);
-    Write<T>(source: T | ObservableProxy, data: any): Promise<void>;
-    Merge<T>(source: T | ObservableProxy, data: Partial<T>): Promise<void>;
-    Push<T>(source: Array<T> | ObservableProxy, data: T): Promise<void>;
-    Splice<T>(source: Array<T> | ObservableProxy, start: number, deleteCount?: number, ...items: Array<T>): Promise<void>;
+    Write<T>(source: T, data: any): Promise<void>;
+    Merge<T>(source: T, data: Partial<T>): Promise<void>;
+    Push<T>(source: Array<T>, data: T): Promise<void>;
+    Splice<T>(source: Array<T>, start: number, deleteCount?: number, ...items: Array<T>): Promise<void>;
     private ApplyChanges;
 }

package/Store/Store/storeAsyncWriter.js

@@ -7,38 +7,34 @@ class StoreAsyncWriter {
         this.observableTree = observableTree;
     }
     async Write(source, data) {
-        var path;
+        let path;
         if (source) {
-            var proxy = source;
-            path = proxy.___node.Path;
+            path = this.observableTree.GetPathOf(source);
         }
         else {
             path = this.idFunc(data);
             if (!path)
                 throw new Error("data must have an id");
         }
-        var diff = await this.diffAsync.DiffPath(path, data);
+        let diff = await this.diffAsync.DiffPath(path, data);
         this.ApplyChanges(diff);
     }
     async Merge(source, data) {
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
-        var keys = Object.keys(data);
-        var message = keys.map(key => ({ path: `${rootPath}.${key}`, value: data[key] }));
-        var diff = await this.diffAsync.DiffBatch(message);
+        const rootPath = this.observableTree.GetPathOf(source);
+        const keys = Object.keys(data);
+        const message = keys.map(key => ({ path: `${rootPath}.${key}`, value: data[key] }));
+        const diff = await this.diffAsync.DiffBatch(message);
         this.ApplyChanges(diff);
     }
     async Push(source, data) {
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
+        const rootPath = this.observableTree.GetPathOf(source);
         var lengthPath = `${rootPath}.length`;
         var length = await this.diffAsync.GetPath(lengthPath);
         var diff = await this.diffAsync.DiffPath(`${rootPath}.${length}`, data);
         this.ApplyChanges(diff);
     }
     async Splice(source, start, deleteCount, ...items) {
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
+        var rootPath = this.observableTree.GetPathOf(source);
         var array = await this.diffAsync.GetPath(rootPath);
         array = array.slice();
         array.splice(start, deleteCount, ...items);

package/Store/Store/storeSync.js

@@ -16,8 +16,8 @@ class StoreSync {
         return this.rootScope;
     }
     Action(action) {
-        var node = this.observableTree.GetNode("ROOT");
-        action(node.Proxy, this.storeWriter);
+        var proxy = this.observableTree.Get("ROOT");
+        action(proxy, this.storeWriter);
     }
     Write(data) {
         this.Action((root, writer) => writer.Write(root, data));
@@ -27,7 +27,6 @@ class StoreSync {
     }
     Destroy() {
         this.rootScope.Destroy();
-        this.observableTree.Destroy();
     }
 }
 exports.StoreSync = StoreSync;

package/Store/Store/storeSyncWriter.d.ts

@@ -1,13 +1,12 @@
 import { ObservableTree } from "../Tree/observableTree";
-import { ObservableProxy } from "../Tree/observableProxy";
 import { DiffSync } from "../Diff/diffSync";
 export declare class StoreSyncWriter {
     private diffSync;
     private observableTree;
     constructor(diffSync: DiffSync, observableTree: ObservableTree);
-    Write<T>(source: T | ObservableProxy, data: any): void;
-    Merge<T>(source: T | ObservableProxy, data: Partial<T>): void;
-    Push<T>(source: Array<T> | ObservableProxy, data: T): void;
-    Splice<T>(source: Array<T> | ObservableProxy, start: number, deleteCount?: number, ...items: Array<T>): any[];
+    Write<T>(source: T, data: any): void;
+    Merge<T>(source: T, data: Partial<T>): void;
+    Push<T>(source: Array<T>, data: T): void;
+    Splice<T>(source: Array<T>, start: number, deleteCount?: number, ...items: Array<T>): void;
     private ApplyChanges;
 }

package/Store/Store/storeSyncWriter.js

@@ -6,35 +6,30 @@ class StoreSyncWriter {
         this.observableTree = observableTree;
     }
     Write(source, data) {
-        var proxy = source;
-        var rootPath = proxy && proxy.___node.Path || "ROOT";
+        var rootPath = source && this.observableTree.GetPathOf(source) || "ROOT";
         var diff = this.diffSync.DiffPath(rootPath, data);
         this.ApplyChanges(diff);
     }
     Merge(source, data) {
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
+        var rootPath = this.observableTree.GetPathOf(source);
         var keys = Object.keys(data);
         var message = keys.map(key => ({ path: `${rootPath}.${key}`, value: data[key] }));
         var diff = this.diffSync.DiffBatch(message);
         this.ApplyChanges(diff);
     }
     Push(source, data) {
-        var array = source;
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
-        var length = array.length;
+        var rootPath = this.observableTree.GetPathOf(source);
+        var length = source.length;
         this.diffSync.UpdatePath(`${rootPath}.${length}`, data);
-        proxy.___node.Push(data);
+        this.observableTree.Write(`${rootPath}.${length}`, data);
     }
     Splice(source, start, deleteCount, ...items) {
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
-        var array = this.observableTree.Get(rootPath);
-        array = array.map(val => val);
+        var rootPath = this.observableTree.GetPathOf(source);
+        var proxy = this.observableTree.Get(rootPath);
+        const array = proxy.toJSON().slice();
         array.splice(start, deleteCount, ...items);
         this.diffSync.UpdatePath(rootPath, array);
-        return proxy.___node.Splice(start, deleteCount, ...items);
+        this.observableTree.Write(rootPath, array);
     }
     ApplyChanges(diff) {
         this.observableTree.WriteAll(diff);

package/Store/Store/storeWriter.d.ts

@@ -1,10 +1,9 @@
 import { ObservableTree } from "../Tree/observableTree";
-import { ObservableProxy } from "../Tree/observableProxy";
 export declare class StoreWriter {
     private observableTree;
     constructor(observableTree: ObservableTree);
-    Write<T>(source: T | ObservableProxy, data: any): void;
-    Merge<T>(source: T | ObservableProxy, data: Partial<T>): void;
-    Push<T>(source: Array<T> | ObservableProxy, data: T): void;
-    Splice<T>(source: Array<T> | ObservableProxy, start: number, deleteCount?: number, ...items: Array<T>): void;
+    Write<T>(source: T, data: any): void;
+    Merge<T>(source: T, data: Partial<T>): void;
+    Push<T>(source: Array<T>, data: T): void;
+    Splice<T>(source: Array<T>, start: number, deleteCount?: number, ...items: Array<T>): void;
 }

package/Store/Store/storeWriter.js

@@ -1,31 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const observableProxy_1 = require("../Tree/observableProxy");
 class StoreWriter {
     constructor(observableTree) {
         this.observableTree = observableTree;
     }
     Write(source, data) {
-        var proxy = source;
-        var rootPath = proxy && proxy.___node.Path || "ROOT";
+        const rootPath = source && this.observableTree.GetPathOf(source) || "ROOT";
         this.observableTree.Write(rootPath, data);
     }
     Merge(source, data) {
-        var proxy = source;
-        var rootPath = proxy.___node.Path;
-        if (observableProxy_1.ObservableProxy.TypeOf(data) === observableProxy_1.Type.Value)
-            this.observableTree.Write(rootPath, data);
-        else
-            for (var key in data)
-                this.observableTree.Write(`${rootPath}.${key}`, data[key]);
+        const rootPath = this.observableTree.GetPathOf(source);
+        for (const key in data)
+            this.observableTree.Write(`${rootPath}.${key}`, data[key]);
     }
     Push(source, data) {
-        var proxy = source;
-        proxy.___node.Push(data);
+        const rootPath = this.observableTree.GetPathOf(source);
+        this.observableTree.Write(`${rootPath}.${length}`, data);
     }
     Splice(source, start, deleteCount, ...items) {
-        var proxy = source;
-        proxy.___node.Splice(start, deleteCount, ...items);
+        const json = source.toJSON();
+        const copy = json.slice();
+        copy.splice(start, deleteCount, ...items);
+        const rootPath = this.observableTree.GetPathOf(source);
+        this.observableTree.Write(rootPath, copy);
     }
 }
 exports.StoreWriter = StoreWriter;

package/Store/Tree/observableScope.js

@@ -131,8 +131,7 @@ function UpdateValue(scope) {
         return;
     scope.dirty = false;
     var value = null;
-    var emitters = WatchAction(() => value = scope.getFunction());
-    UpdateEmitters(scope, emitters);
+    var emitters = scope.getFunction && WatchAction(() => value = scope.getFunction());
     if (scope.async)
         Promise.resolve(value).then(val => {
             scope.value = val;
@@ -140,6 +139,7 @@ function UpdateValue(scope) {
         });
     else
         scope.value = value;
+    UpdateEmitters(scope, emitters);
 }
 function DestroyScope(scope) {
     if (!scope)

package/Store/Tree/observableTree.d.ts

@@ -1,24 +1,33 @@
-import { ObservableNode } from "./observableNode";
-import { ObservableScope } from "./observableScope";
+import { ObservableScope } from "../Tree/observableScope";
 export declare class ObservableTree {
     private valuePathResolver?;
+    private undefinedScope;
+    private scopeCache;
+    private leafScopeCache;
+    private proxyCache;
+    private pathCache;
     private rootStateMap;
-    private rootNodeMap;
     constructor(valuePathResolver?: {
-        (value: string): string;
+        (value: string): string | undefined;
     });
+    Get<O>(path: string): O;
+    GetPathOf(value: any): string;
+    Scope<O, R = O>(path: string, callback?: {
+        (obj: O): R;
+    }): ObservableScope<O | R>;
     Write(path: string, value: any): void;
     WriteAll(data: Array<{
         path: string;
         value: any;
     }>): void;
-    Get<O>(path?: string): O;
-    GetNode(path: string): ObservableNode;
-    Delete(path: string): void;
-    Destroy(): void;
-    Scope<O, R = O>(path: string, func?: {
-        (val: O): R;
-    }): ObservableScope<R>;
+    private GetParentScope;
+    private GetPropertyScope;
+    private GetValueProxy;
+    private ObjectProxyGetter;
+    private CreateObjectProxy;
+    private ArrayProxyGetter;
+    private CreateArrayProxy;
+    private CreateProxy;
     private WritePath;
-    private UpdatePathNode;
+    private UpdatePathCache;
 }

package/Store/Tree/observableTree.js

@@ -1,91 +1,215 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const observableNode_1 = require("./observableNode");
-const observableProxy_1 = require("./observableProxy");
-const observableScope_1 = require("./observableScope");
+const observableScope_1 = require("../Tree/observableScope");
+var Type;
+(function (Type) {
+    Type[Type["Value"] = 0] = "Value";
+    Type[Type["Object"] = 1] = "Object";
+    Type[Type["Array"] = 2] = "Array";
+})(Type || (Type = {}));
+const jsonConstructor = {}.constructor;
+function TypeOf(value) {
+    if (!value)
+        return Type.Value;
+    if (jsonConstructor === value.constructor)
+        return Type.Object;
+    if (Array.isArray(value))
+        return Type.Array;
+    return Type.Value;
+}
 class ObservableTree {
     constructor(valuePathResolver) {
         this.valuePathResolver = valuePathResolver;
+        this.undefinedScope = observableScope_1.ObservableScope.Create(function () { return undefined; });
+        this.scopeCache = new WeakMap();
+        this.leafScopeCache = new WeakMap();
+        this.proxyCache = new WeakMap();
+        this.pathCache = new WeakMap();
         this.rootStateMap = new Map();
-        this.rootNodeMap = new Map();
-    }
-    Write(path, value) {
-        this.WritePath(path, value);
-        this.UpdatePathNode(path);
-    }
-    WriteAll(data) {
-        for (var x = 0; x < data.length; x++)
-            this.WritePath(data[x].path, data[x].value);
-        for (var y = 0; y < data.length; y++)
-            this.UpdatePathNode(data[y].path);
+        this.ObjectProxyGetter = (value, prop) => {
+            function toJSON() {
+                return value;
+            }
+            ;
+            switch (prop) {
+                case "toJSON":
+                    return toJSON;
+                default:
+                    if (typeof prop === 'symbol')
+                        return value[prop];
+                    return observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, prop));
+            }
+        };
+        this.ArrayProxyGetter = (value, prop) => {
+            function toJSON() {
+                return value;
+            }
+            ;
+            switch (prop) {
+                case "toJSON":
+                    return toJSON;
+                default:
+                    if (typeof prop === 'symbol')
+                        return value[prop];
+                    if (isNaN(parseInt(prop))) {
+                        const ret = value[prop];
+                        if (typeof ret === 'function') {
+                            const copy = value.map((val, index) => observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, index.toString())));
+                            return ret.bind(copy);
+                        }
+                        return ret;
+                    }
+                    return observableScope_1.ObservableScope.Value(this.GetPropertyScope(value, prop));
+            }
+        };
     }
     Get(path) {
-        return path.split(".").reduce((pre, curr, index) => {
-            if (index === 0)
-                return this.rootStateMap.get(curr);
-            return pre && pre[curr];
-        }, null);
-    }
-    GetNode(path) {
-        return path.split(".").reduce((pre, curr, index) => {
+        const val = path.split(".").reduce((pre, curr, index) => {
             if (index === 0) {
-                var ret = this.rootNodeMap.get(curr);
-                if (!ret) {
-                    ret = new observableNode_1.ObservableNode(this, curr, null, this.valuePathResolver);
-                    this.rootNodeMap.set(curr, ret);
-                }
-                return ret;
+                let value = this.rootStateMap.get(curr);
+                const scope = this.GetParentScope(value);
+                return observableScope_1.ObservableScope.Value(scope);
             }
-            return pre.EnsureChild(curr);
+            return pre && pre[curr];
         }, null);
+        return val;
     }
-    Delete(path) {
-        var node = this.GetNode(path);
-        node.Destroy();
-    }
-    Destroy() {
-        this.rootStateMap.clear();
-        this.rootNodeMap.forEach(node => node.Destroy());
-        this.rootNodeMap.clear();
+    GetPathOf(value) {
+        if (value.toJSON && typeof value.toJSON === 'function')
+            value = value.toJSON();
+        return this.pathCache.get(value);
     }
-    Scope(path, func) {
+    Scope(path, callback) {
         return new observableScope_1.ObservableScope(() => {
-            var node = this.GetNode(path);
-            return func && func(node.Proxy) || node.Proxy;
+            const obj = this.Get(path);
+            return callback && callback(obj) || obj;
         });
     }
-    WritePath(path, value) {
-        var pathParts = path.split(".");
-        var rootPart = pathParts[0];
-        if (pathParts.length === 1)
-            this.rootStateMap.set(rootPart, value);
-        else {
-            var curValue = this.rootStateMap.get(rootPart);
-            for (var x = 1; x < pathParts.length - 1; x++) {
-                if (!curValue)
-                    throw new Error("Unable to write path: " + path + ". Falsey value found at: " + pathParts.slice(0, x).join("."));
-                curValue = curValue[pathParts[x]];
-            }
-            if (!curValue)
-                throw new Error("Unable to write path: " + path + ". Falsey value found at: " + pathParts.slice(0, x).join("."));
-            curValue[pathParts[x]] = value;
+    Write(path, value) {
+        const scope = this.WritePath(path, value);
+        observableScope_1.ObservableScope.Update(scope);
+    }
+    WriteAll(data) {
+        const scopeSet = new Set();
+        for (var x = 0; x < data.length; x++) {
+            const scope = this.WritePath(data[x].path, data[x].value);
+            scopeSet.add(scope);
         }
+        scopeSet.forEach(scope => observableScope_1.ObservableScope.Update(scope));
     }
-    UpdatePathNode(path) {
-        var node = this.GetNode(path);
-        node.Update();
-        if (node.Parent && node.Parent.Type === observableProxy_1.Type.Array) {
-            node.Parent.ArrayUpdate();
-            if (node.Key === 'length') {
-                var index = node.Value;
-                var childNode = node.Parent.Children.get(index.toString());
-                while (childNode) {
-                    childNode.Destroy();
-                    index++;
-                    childNode = node.Parent.Children.get(index.toString());
+    GetParentScope(value) {
+        const type = TypeOf(value);
+        if (type === Type.Value) {
+            if (this.valuePathResolver && typeof value === 'string') {
+                const path = this.valuePathResolver(value);
+                if (path) {
+                    const val = this.rootStateMap.get(path);
+                    return this.GetParentScope(val);
                 }
             }
+            return value === undefined ? this.undefinedScope : observableScope_1.ObservableScope.Create(value);
+        }
+        let scope = this.scopeCache.get(value);
+        if (!scope) {
+            scope = observableScope_1.ObservableScope.Create(() => this.GetValueProxy(value));
+            this.scopeCache.set(value, scope);
+        }
+        return scope;
+    }
+    GetPropertyScope(parent, prop) {
+        const value = parent[prop];
+        const type = TypeOf(value);
+        if (type === Type.Value) {
+            let leafScopes = this.leafScopeCache.get(parent) || {};
+            leafScopes[prop] = leafScopes[prop] || observableScope_1.ObservableScope.Create(() => {
+                const parentScope = this.scopeCache.get(parent);
+                const parentValue = observableScope_1.ObservableScope.Value(parentScope);
+                const parentJson = parentValue.toJSON();
+                const currentValue = parentJson[prop];
+                let path;
+                if (this.valuePathResolver && typeof currentValue === 'string' && (path = this.valuePathResolver(currentValue)))
+                    return this.Get(path);
+                return currentValue;
+            });
+            this.leafScopeCache.set(parent, leafScopes);
+            return leafScopes[prop];
+        }
+        else {
+            let scope = this.scopeCache.get(value);
+            if (!scope) {
+                scope = observableScope_1.ObservableScope.Create(() => {
+                    const parentScope = this.scopeCache.get(parent);
+                    const parentValue = observableScope_1.ObservableScope.Value(parentScope);
+                    const parentJson = parentValue.toJSON();
+                    const currentValue = parentJson[prop];
+                    return this.GetValueProxy(currentValue);
+                });
+                this.scopeCache.set(value, scope);
+            }
+            return scope;
+        }
+    }
+    GetValueProxy(value) {
+        let proxy = this.proxyCache.get(value);
+        if (!proxy) {
+            proxy = this.CreateProxy(value);
+            this.proxyCache.set(value, proxy);
+        }
+        return proxy;
+    }
+    CreateObjectProxy(value) {
+        return new Proxy(value, {
+            get: this.ObjectProxyGetter
+        });
+    }
+    CreateArrayProxy(value) {
+        return new Proxy(value, {
+            get: this.ArrayProxyGetter
+        });
+    }
+    CreateProxy(value) {
+        const type = TypeOf(value);
+        switch (type) {
+            case Type.Object:
+                return this.CreateObjectProxy(value);
+            case Type.Array:
+                return this.CreateArrayProxy(value);
+            default:
+                return value;
         }
     }
+    WritePath(path, value) {
+        this.UpdatePathCache(path, value);
+        const pathParts = path.split(".");
+        if (pathParts.length === 1) {
+            const currentValue = this.rootStateMap.get(pathParts[0]);
+            this.rootStateMap.set(pathParts[0], value);
+            return currentValue === undefined ? this.undefinedScope : this.scopeCache.get(currentValue);
+        }
+        let parentValue;
+        let x = 0;
+        for (; x < pathParts.length - 1 && (x === 0 || parentValue); x++) {
+            if (x === 0)
+                parentValue = this.rootStateMap.get(pathParts[x]);
+            else
+                parentValue = parentValue && parentValue[pathParts[x]];
+        }
+        if (!parentValue)
+            throw new Error("Unable to write path: " + path + ". Falsey value found at: " + pathParts.slice(0, x).join("."));
+        const prop = pathParts[x];
+        parentValue[prop] = value;
+        const leafScopes = this.leafScopeCache.get(parentValue);
+        return leafScopes && leafScopes[prop] || this.scopeCache.get(parentValue);
+    }
+    UpdatePathCache(path, value) {
+        const type = TypeOf(value);
+        if (type === Type.Value)
+            return;
+        this.pathCache.set(value, path);
+        const keys = Object.keys(value);
+        for (let x = 0; x < keys.length; x++)
+            this.UpdatePathCache(`${path}.${keys[x]}`, value[keys[x]]);
+        return value;
+    }
 }
 exports.ObservableTree = ObservableTree;

package/Utils/asyncQueue.js

@@ -7,7 +7,7 @@ class AsyncQueue {
         this.queue = list_1.List.Create();
     }
     Next(callback) {
-        const ret = new Promise(async function (resolve, reject) {
+        const ret = new Promise((resolve, reject) => {
             list_1.List.Add(this.queue, async function () {
                 try {
                     const ret = await callback();

package/Utils/thread.d.ts

@@ -13,4 +13,4 @@ export declare function Thread(callback: {
 }): void;
 export declare function ThreadAsync(callback: {
     (): void;
-}): Promise<unknown>;
+}): Promise<void>;