j-templates 5.0.45 → 5.0.47

package/Store/Tree/observableTree.d.ts

@@ -1,33 +1,34 @@
-import { ObservableScope } from "../Tree/observableScope";
-export declare class ObservableTree {
-    private valuePathResolver?;
-    private undefinedScope;
-    private scopeCache;
-    private leafScopeCache;
-    private proxyCache;
-    private pathCache;
-    private rootStateMap;
-    constructor(valuePathResolver?: {
-        (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;
-    private GetParentScope;
-    private GetPropertyScope;
-    private GetValueProxy;
-    private ObjectProxyGetter;
-    private CreateObjectProxy;
-    private ArrayProxyGetter;
-    private CreateArrayProxy;
-    private CreateProxy;
-    private WritePath;
-    private UpdatePathCache;
-}
+import { ObservableScope } from "../Tree/observableScope";
+export declare class ObservableTree {
+    private valuePathResolver?;
+    private undefinedScope;
+    private scopeCache;
+    private leafScopeCache;
+    private proxyCache;
+    private pathCache;
+    private rootStateMap;
+    constructor(valuePathResolver?: {
+        (value: string): string | undefined;
+    });
+    static UnwrapProxyValues(value: any): any;
+    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;
+    private GetParentScope;
+    private GetPropertyScope;
+    private GetValueProxy;
+    private ObjectProxyGetter;
+    private CreateObjectProxy;
+    private ArrayProxyGetter;
+    private CreateArrayProxy;
+    private CreateProxy;
+    private WritePath;
+    private UpdatePathCache;
+}

package/Store/Tree/observableTree.js

@@ -1,214 +1,232 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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;
-    }
-    Get(path) {
-        const val = path.split(".").reduce((pre, curr, index) => {
-            if (index === 0) {
-                let value = this.rootStateMap.get(curr);
-                const scope = this.GetParentScope(value);
-                return observableScope_1.ObservableScope.Value(scope);
-            }
-            return pre && pre[curr];
-        }, null);
-        return val;
-    }
-    GetPathOf(value) {
-        if (value.toJSON && typeof value.toJSON === 'function')
-            value = value.toJSON();
-        return this.pathCache.get(value);
-    }
-    Scope(path, callback) {
-        return new observableScope_1.ObservableScope(() => {
-            const obj = this.Get(path);
-            return callback && callback(obj) || obj;
-        });
-    }
-    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) {
-        if (value === undefined)
-            return this.undefinedScope;
-        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;
-    }
-    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);
-        const oldValue = parentValue[prop];
-        const oldType = TypeOf(oldValue);
-        parentValue[prop] = value;
-        if (oldType !== Type.Value)
-            return this.scopeCache.get(oldValue) ||
-                this.scopeCache.get(parentValue);
-        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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+    }
+    static UnwrapProxyValues(value) {
+        if (value?.toJSON && typeof value.toJSON === 'function')
+            return value.toJSON();
+        const type = TypeOf(value);
+        if (type === Type.Value)
+            return value;
+        if (type === Type.Array) {
+            const arr = value;
+            for (let x = 0; x < arr.length; x++)
+                arr[x] = ObservableTree.UnwrapProxyValues(arr[x]);
+        }
+        else {
+            const keys = Object.keys(value);
+            for (let x = 0; x < keys.length; x++)
+                value[keys[x]] = ObservableTree.UnwrapProxyValues(value[keys[x]]);
+        }
+        return value;
+    }
+    Get(path) {
+        const val = path.split(".").reduce((pre, curr, index) => {
+            if (index === 0) {
+                let value = this.rootStateMap.get(curr);
+                const scope = this.GetParentScope(value);
+                return observableScope_1.ObservableScope.Value(scope);
+            }
+            return pre && pre[curr];
+        }, null);
+        return val;
+    }
+    GetPathOf(value) {
+        if (value.toJSON && typeof value.toJSON === 'function')
+            value = value.toJSON();
+        return this.pathCache.get(value);
+    }
+    Scope(path, callback) {
+        return new observableScope_1.ObservableScope(() => {
+            const obj = this.Get(path);
+            return callback && callback(obj) || obj;
+        });
+    }
+    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) {
+        if (value === undefined)
+            return this.undefinedScope;
+        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;
+    }
+    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);
+        const oldValue = parentValue[prop];
+        const oldType = TypeOf(oldValue);
+        parentValue[prop] = value;
+        if (oldType !== Type.Value)
+            return this.scopeCache.get(oldValue) ||
+                this.scopeCache.get(parentValue);
+        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.d.ts

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

package/Store/index.js

@@ -1,11 +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");
-Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return store_1.Store; } });
-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; } });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableScope = exports.StoreAsync = exports.StoreSync = exports.Store = void 0;
+var store_1 = require("./Store/store");
+Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return store_1.Store; } });
+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; } });

package/Utils/animation.d.ts

@@ -1,29 +1,29 @@
-import { IDestroyable } from "./utils.types";
-export declare enum AnimationType {
-    Linear = 0,
-    EaseIn = 1
-}
-export declare class Animation implements IDestroyable {
-    private type;
-    private frameCount;
-    private frameTimings;
-    private update;
-    private animationTimeouts;
-    private running;
-    private start;
-    private end;
-    private enabled;
-    get Running(): boolean;
-    get Start(): number;
-    get End(): number;
-    get Enabled(): boolean;
-    constructor(type: AnimationType, duration: number, update: {
-        (next: number): void;
-    });
-    Animate(start: number, end: number): Promise<void>;
-    Disable(): void;
-    Enable(): void;
-    Cancel(): void;
-    Destroy(): void;
-    private SetTimeout;
-}
+import { IDestroyable } from "./utils.types";
+export declare enum AnimationType {
+    Linear = 0,
+    EaseIn = 1
+}
+export declare class Animation implements IDestroyable {
+    private type;
+    private frameCount;
+    private frameTimings;
+    private update;
+    private animationTimeouts;
+    private running;
+    private start;
+    private end;
+    private enabled;
+    get Running(): boolean;
+    get Start(): number;
+    get End(): number;
+    get Enabled(): boolean;
+    constructor(type: AnimationType, duration: number, update: {
+        (next: number): void;
+    });
+    Animate(start: number, end: number): Promise<void>;
+    Disable(): void;
+    Enable(): void;
+    Cancel(): void;
+    Destroy(): void;
+    private SetTimeout;
+}