j-templates 5.0.37 → 5.0.39

package/Store/Store/storeSyncWriter.js

@@ -1,40 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreSyncWriter = void 0;
 class StoreSyncWriter {
+    diffSync;
+    observableTree;
     constructor(diffSync, observableTree) {
         this.diffSync = diffSync;
         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,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const observableProxy_1 = require("../Tree/observableProxy");
+exports.StoreWriter = void 0;
 class StoreWriter {
+    observableTree;
     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

@@ -1,16 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableScope = exports.ObservableScopeWrapper = exports.ObservableScopeValue = void 0;
 const emitter_1 = require("../../Utils/emitter");
 class ObservableScopeValue {
-    constructor(scope) {
-        this.scope = scope;
-    }
+    scope;
     get Value() {
         return ObservableScope.Value(this.scope);
     }
+    constructor(scope) {
+        this.scope = scope;
+    }
 }
 exports.ObservableScopeValue = ObservableScopeValue;
 class ObservableScopeWrapper extends ObservableScopeValue {
+    scopeEmitter;
     constructor(scope) {
         super(scope);
         if (scope.emitter) {
@@ -131,8 +134,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 +142,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,218 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const observableNode_1 = require("./observableNode");
-const observableProxy_1 = require("./observableProxy");
-const observableScope_1 = require("./observableScope");
+exports.ObservableTree = void 0;
+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 {
+    valuePathResolver;
+    undefinedScope = observableScope_1.ObservableScope.Create(function () { return undefined; });
+    scopeCache = new WeakMap();
+    leafScopeCache = new WeakMap();
+    proxyCache = new WeakMap();
+    pathCache = new WeakMap();
+    rootStateMap = new Map();
     constructor(valuePathResolver) {
         this.valuePathResolver = valuePathResolver;
-        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);
     }
     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();
+    GetPathOf(value) {
+        if (value.toJSON && typeof value.toJSON === 'function')
+            value = value.toJSON();
+        return this.pathCache.get(value);
     }
-    Destroy() {
-        this.rootStateMap.clear();
-        this.rootNodeMap.forEach(node => node.Destroy());
-        this.rootNodeMap.clear();
-    }
-    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);
+    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));
+    }
+    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 {
-            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]];
+            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);
             }
-            if (!curValue)
-                throw new Error("Unable to write path: " + path + ". Falsey value found at: " + pathParts.slice(0, x).join("."));
-            curValue[pathParts[x]] = value;
+            return scope;
+        }
+    }
+    GetValueProxy(value) {
+        let proxy = this.proxyCache.get(value);
+        if (!proxy) {
+            proxy = this.CreateProxy(value);
+            this.proxyCache.set(value, proxy);
         }
+        return proxy;
     }
-    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());
+    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));
+        }
+    };
+    CreateObjectProxy(value) {
+        return new Proxy(value, {
+            get: this.ObjectProxyGetter
+        });
+    }
+    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));
         }
+    };
+    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];
+        const exists = Object.hasOwn(parentValue, prop);
+        parentValue[prop] = value;
+        const leafScopes = exists && 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/Store/index.js

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

package/Utils/animation.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Animation = exports.AnimationType = void 0;
 var StepFunctions;
 (function (StepFunctions) {
     function* EaseIn(count) {
@@ -21,6 +22,27 @@ var AnimationType;
     AnimationType[AnimationType["EaseIn"] = 1] = "EaseIn";
 })(AnimationType = exports.AnimationType || (exports.AnimationType = {}));
 class Animation {
+    type;
+    frameCount;
+    frameTimings;
+    update;
+    animationTimeouts;
+    running;
+    start;
+    end;
+    enabled;
+    get Running() {
+        return this.running;
+    }
+    get Start() {
+        return this.start;
+    }
+    get End() {
+        return this.end;
+    }
+    get Enabled() {
+        return this.enabled;
+    }
     constructor(type, duration, update) {
         this.running = false;
         this.start = null;
@@ -35,18 +57,6 @@ class Animation {
         this.update = update;
         this.animationTimeouts = [];
     }
-    get Running() {
-        return this.running;
-    }
-    get Start() {
-        return this.start;
-    }
-    get End() {
-        return this.end;
-    }
-    get Enabled() {
-        return this.enabled;
-    }
     Animate(start, end) {
         if (!this.enabled)
             return;

package/Utils/asyncQueue.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
 const list_1 = require("./list");
 class AsyncQueue {
-    constructor() {
-        this.running = false;
-        this.queue = list_1.List.Create();
-    }
+    running = false;
+    queue = list_1.List.Create();
     Next(callback) {
         const ret = new Promise((resolve, reject) => {
             list_1.List.Add(this.queue, async function () {

package/Utils/decorators.d.ts

@@ -22,7 +22,7 @@ export declare namespace Destroy {
 declare function DestroyDecorator<T extends Component<any, any, any> & Record<K, IDestroyable>, K extends string>(target: T, propertyKey: K): any;
 export declare function PreReqTemplate(template: {
     (): NodeRefTypes | NodeRefTypes[];
-}): <T extends Component<any, any, any>>(target: new (...args: any[]) => T) => any;
+}): <T extends Component<any, any, any>>(target: new (...args: Array<any>) => T) => any;
 export declare namespace PreReqTemplate {
     function Get(value: any): NodeRefTypes[];
 }

package/Utils/decorators.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreReq = exports.PreReqTemplate = exports.Destroy = exports.Inject = exports.ComputedAsync = exports.Computed = exports.DestroyScope = exports.Scope = exports.StateAsync = exports.StateSync = exports.State = void 0;
 const store_1 = require("../Store/Store/store");
 const Store_1 = require("../Store");
 const observableScope_1 = require("../Store/Tree/observableScope");

package/Utils/emitter.d.ts

@@ -1,7 +1,7 @@
-export declare type EmitterCallback = {
+export type EmitterCallback = {
     (...args: any[]): void;
 };
-export declare type Emitter = Set<{
+export type Emitter = Set<{
     (...args: any[]): void;
 }>;
 export declare namespace Emitter {

package/Utils/emitter.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = void 0;
 var Emitter;
 (function (Emitter) {
     function Create() {

package/Utils/index.js

@@ -1,7 +1,18 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./decorators"));
-__export(require("./animation"));
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./animation"), exports);

package/Utils/injector.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = void 0;
 class Injector {
+    parent;
+    typeMap;
     constructor() {
         this.parent = Injector.Current();
         this.typeMap = new Map();

package/Utils/list.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.List = void 0;
 var List;
 (function (List) {
     function Create() {