j-templates 5.0.53 → 6.0.0

package/Node/component.d.ts

@@ -6,10 +6,8 @@ export declare class Component<D = void, T = void, E = void> {
     private componentEvents;
     private scope;
     private templates;
-    private decoratorMap;
     get Injector(): import("../Utils/injector").Injector;
     get Destroyed(): boolean;
-    get DecoratorMap(): Map<string, any>;
     protected get Scope(): ObservableScope<D>;
     protected get Data(): D;
     protected get NodeRef(): INodeRefBase;

package/Node/component.js

@@ -10,16 +10,12 @@ class Component {
     componentEvents;
     scope;
     templates;
-    decoratorMap;
     get Injector() {
         return this.nodeRef.injector;
     }
     get Destroyed() {
         return this.nodeRef.destroyed;
     }
-    get DecoratorMap() {
-        return this.decoratorMap;
-    }
     get Scope() {
         return this.scope;
     }
@@ -37,13 +33,11 @@ class Component {
         this.componentEvents = componentEvents;
         this.scope = new observableScope_1.ObservableScope(data);
         this.templates = templates || {};
-        this.decoratorMap = new Map();
     }
     Template() {
         return [];
     }
-    Bound() {
-    }
+    Bound() { }
     Fire(event, data) {
         var eventCallback = this.componentEvents && this.componentEvents[event];
         eventCallback && eventCallback(data);
@@ -64,7 +58,7 @@ exports.Component = Component;
         class WebComponent extends HTMLElement {
             constructor() {
                 super();
-                const shadowRoot = this.attachShadow({ mode: 'open' });
+                const shadowRoot = this.attachShadow({ mode: "open" });
                 const node = componentFunction({});
                 Attach(shadowRoot, node);
             }

package/Store/Diff/diffAsync.d.ts

@@ -1,17 +1,18 @@
-import { IDiffResponse } from "./diffTree";
-export declare class DiffAsync {
+import { IDiffTree } from "./diffTree";
+import { JsonDiffResult } from "../../Utils/json";
+type IDiffTreeAsync = {
+    [property in keyof IDiffTree]: (...args: Parameters<IDiffTree[property]>) => Promise<ReturnType<IDiffTree[property]>>;
+};
+export declare class DiffAsync implements IDiffTreeAsync {
     private workerQueue;
     constructor(keyFunc?: {
         (val: any): string;
     });
-    static GetKeyRef(key: string): string;
-    static ReadKeyRef(ref: string): string;
-    DiffPath(path: string, value: any): Promise<IDiffResponse>;
+    DiffPath(path: string, value: any): Promise<JsonDiffResult>;
     DiffBatch(data: Array<{
         path: string;
         value: any;
-    }>): Promise<IDiffResponse>;
-    UpdatePath(path: string, value: any): Promise<void>;
-    GetPath(path: string): Promise<any>;
+    }>): Promise<JsonDiffResult>;
     Destroy(): void;
 }
+export {};

package/Store/Diff/diffAsync.js

@@ -1,21 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiffAsync = void 0;
-const diffTree_1 = require("./diffTree");
 const workerQueue_1 = require("./workerQueue");
 const diffWorker_1 = require("./diffWorker");
-const diffCnstr = (0, diffTree_1.DiffTreeScope)();
 class DiffAsync {
     workerQueue;
     constructor(keyFunc) {
         this.workerQueue = new workerQueue_1.WorkerQueue(diffWorker_1.DiffWorker.Create());
-        this.workerQueue.Push({ method: "create", arguments: [keyFunc.toString()] });
-    }
-    static GetKeyRef(key) {
-        return diffCnstr.GetKeyRef(key);
-    }
-    static ReadKeyRef(ref) {
-        return diffCnstr.ReadKeyRef(ref);
+        this.workerQueue.Push({ method: "create", arguments: keyFunc ? [keyFunc.toString()] : [] });
     }
     async DiffPath(path, value) {
         return await this.workerQueue.Push({ method: "diffpath", arguments: [path, value] });
@@ -23,12 +15,6 @@ class DiffAsync {
     async DiffBatch(data) {
         return await this.workerQueue.Push({ method: "diffbatch", arguments: [data] });
     }
-    async UpdatePath(path, value) {
-        await this.workerQueue.Push({ method: "updatepath", arguments: [path, value] });
-    }
-    async GetPath(path) {
-        return await this.workerQueue.Push({ method: "getpath", arguments: [path] });
-    }
     Destroy() {
         this.workerQueue.Destroy();
     }

package/Store/Diff/diffSync.d.ts

@@ -1,14 +1,12 @@
-export declare class DiffSync {
+import { IDiffTree } from "./diffTree";
+export declare class DiffSync implements IDiffTree {
     private diffTree;
     constructor(keyFunc?: {
         (val: any): string;
     });
-    static GetKeyRef(key: string): string;
-    static ReadKeyRef(ref: string): string;
-    DiffPath(path: string, value: any): import("./diffTree").IDiffResponse;
+    DiffPath(path: string, value: any): import("../../Utils/json").JsonDiffResult;
     DiffBatch(data: Array<{
         path: string;
         value: any;
-    }>): import("./diffTree").IDiffResponse;
-    UpdatePath(path: string, value: any): void;
+    }>): import("../../Utils/json").JsonDiffResult;
 }

package/Store/Diff/diffSync.js

@@ -1,27 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiffSync = void 0;
+const jsonDeepClone_1 = require("../../Utils/jsonDeepClone");
 const diffTree_1 = require("./diffTree");
-const diffCnstr = (0, diffTree_1.DiffTreeScope)();
+const diffCnstr = (0, diffTree_1.DiffTreeFactory)();
 class DiffSync {
     diffTree;
     constructor(keyFunc) {
         this.diffTree = new diffCnstr(keyFunc);
     }
-    static GetKeyRef(key) {
-        return diffCnstr.GetKeyRef(key);
-    }
-    static ReadKeyRef(ref) {
-        return diffCnstr.ReadKeyRef(ref);
-    }
     DiffPath(path, value) {
+        value = (0, jsonDeepClone_1.JsonDeepClone)(value);
         return this.diffTree.DiffPath(path, value);
     }
     DiffBatch(data) {
+        data = (0, jsonDeepClone_1.JsonDeepClone)(data);
         return this.diffTree.DiffBatch(data);
     }
-    UpdatePath(path, value) {
-        this.diffTree.UpdatePath(path, value);
-    }
 }
 exports.DiffSync = DiffSync;

package/Store/Diff/diffTree.d.ts

@@ -1,24 +1,18 @@
+import { JsonDiffFactoryResult, JsonDiffResult } from "../../Utils/json";
 export interface IDiffMethod {
     method: "create" | "diffpath" | "diffbatch" | "updatepath" | "getpath";
     arguments: Array<any>;
 }
-export type IDiffResponse = {
-    path: string;
-    value: any;
-}[];
 export interface IDiffTree {
     DiffBatch(data: Array<{
         path: string;
         value: any;
-    }>): IDiffResponse;
-    DiffPath(path: string, value: any): IDiffResponse;
-    UpdatePath(path: string, value: any): void;
+    }>): JsonDiffResult;
+    DiffPath(path: string, value: any): JsonDiffResult;
 }
 export interface IDiffTreeConstructor {
     new (keyFunc?: {
         (val: any): string;
     }): IDiffTree;
-    GetKeyRef(key: string): string;
-    ReadKeyRef(ref: string): string;
 }
-export declare function DiffTreeScope(worker?: boolean): IDiffTreeConstructor;
+export declare function DiffTreeFactory(jsonDiffFactory?: () => JsonDiffFactoryResult, worker?: boolean): IDiffTreeConstructor;

package/Store/Diff/diffTree.js

@@ -1,230 +1,137 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffTreeScope = DiffTreeScope;
-function DiffTreeScope(worker) {
+exports.DiffTreeFactory = DiffTreeFactory;
+function DiffTreeFactory(jsonDiffFactory, worker) {
+    const { JsonDiff, JsonType } = jsonDiffFactory();
     const ctx = this;
     if (ctx && worker) {
         let diffTree = null;
         ctx.onmessage = function (event) {
-            var data = event.data;
+            const data = event.data;
             switch (data.method) {
-                case "create":
-                    var keyFunc = data.arguments[0] ? eval(data.arguments[0]) : undefined;
+                case "create": {
+                    const keyFunc = data.arguments[0]
+                        ? eval(data.arguments[0])
+                        : undefined;
                     diffTree = new DiffTree(keyFunc);
                     ctx.postMessage(null);
                     break;
-                case "diffpath":
-                    var diff = diffTree.DiffPath(data.arguments[0], data.arguments[1]);
+                }
+                case "diffpath": {
+                    const diff = diffTree.DiffPath(data.arguments[0], data.arguments[1]);
                     ctx.postMessage(diff);
                     break;
-                case "diffbatch":
-                    var diff = diffTree.DiffBatch(data.arguments[0]);
+                }
+                case "diffbatch": {
+                    const diff = diffTree.DiffBatch(data.arguments[0]);
                     ctx.postMessage(diff);
                     break;
-                case "updatepath":
-                    diffTree.UpdatePath(data.arguments[0], data.arguments[1]);
-                    ctx.postMessage(null);
-                    break;
-                case "getpath":
-                    var ret = diffTree.GetPath(data.arguments[0]);
+                }
+                case "getpath": {
+                    const ret = diffTree.GetPath(data.arguments[0]);
                     ctx.postMessage(ret);
                     break;
+                }
             }
         };
     }
-    const jsonConstructor = {}.constructor;
-    function IsValue(value) {
-        if (!value)
-            return true;
-        return !(jsonConstructor === value.constructor || Array.isArray(value));
+    function FlattenValue(root, value, keyFunc) {
+        const type = JsonType(value);
+        switch (type) {
+            case "array":
+                const typedArray = value;
+                for (let x = 0; x < typedArray.length; x++)
+                    FlattenValue(root, typedArray[x], keyFunc);
+                break;
+            case "object":
+                const typedObject = value;
+                const key = keyFunc(typedObject);
+                if (key)
+                    root[key] = typedObject;
+                const keys = Object.keys(typedObject);
+                for (let x = 0; x < keys.length; x++)
+                    FlattenValue(root, typedObject[keys[x]], keyFunc);
+        }
+        return root;
     }
-    let Type;
-    (function (Type) {
-        Type[Type["Value"] = 0] = "Value";
-        Type[Type["Object"] = 1] = "Object";
-        Type[Type["Array"] = 2] = "Array";
-    })(Type || (Type = {}));
-    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;
+    function GetPathValue(source, path) {
+        if (path === "")
+            return source;
+        const parts = path.split(".");
+        let curr = source;
+        for (let x = 0; x < parts.length; x++)
+            curr = curr[parts[x]];
+        return curr;
     }
-    function JsonDiffRecursive(path, newValue, oldValue, resp) {
-        if (newValue === oldValue)
-            return false;
-        const newType = TypeOf(newValue);
-        const oldType = TypeOf(oldValue);
-        const changedPathLength = resp.length;
-        let allChildrenChanged = true;
-        if (newType === oldType)
-            switch (newType) {
-                case Type.Array: {
-                    allChildrenChanged = JsonDiffArrays(path, newValue, oldValue, resp);
-                    break;
-                }
-                case Type.Object: {
-                    allChildrenChanged = JsonDiffObjects(path, newValue, oldValue, resp);
-                    break;
-                }
-            }
-        if (allChildrenChanged) {
-            resp.splice(changedPathLength);
-            resp.push({
-                path,
-                value: newValue
-            });
-            return true;
-        }
-        return false;
+    function SetPathValue(source, path, value) {
+        if (path.length === 0)
+            return;
+        let curr = source;
+        let x = 0;
+        for (; x < path.length - 1; x++)
+            curr = curr[path[x]];
+        curr[path[x]] = value;
     }
-    function JsonDiffArrays(path, newValue, oldValue, resp) {
-        let allChildrenChanged = true;
-        if (newValue.length !== oldValue.length)
-            resp.push({
-                path: path ? `${path}.length` : 'length',
-                value: newValue.length
-            });
-        if (newValue.length > 0 || oldValue.length > 0) {
-            for (let y = 0; y < newValue.length; y++) {
-                const arrayPath = path ? `${path}.${y}` : `${y}`;
-                allChildrenChanged = JsonDiffRecursive(arrayPath, newValue[y], oldValue[y], resp) && allChildrenChanged;
-            }
-        }
-        else
-            allChildrenChanged = false;
-        return allChildrenChanged;
+    function ResolveKeyPath(source, path, keyFunc) {
+        const parts = path.split('.');
+        const pathValues = new Array(parts.length - 1);
+        let curr = source;
+        for (let x = 0; x < parts.length - 1; x++) {
+            curr = curr[parts[x]];
+            pathValues[x] = curr;
+        }
+        let y = pathValues.length - 1;
+        for (; y >= 0 && !(JsonType(pathValues[y]) === 'object' && keyFunc(pathValues[y])); y--) { }
+        if (y >= 0) {
+            const key = keyFunc(pathValues[y]);
+            parts.splice(0, y + 1, key);
+            return parts.join('.');
+        }
+        return path;
     }
-    function JsonDiffObjects(path, newValue, oldValue, resp) {
-        let allChildrenChanged = true;
-        const newKeys = Object.keys(newValue);
-        const oldKeys = Object.keys(oldValue);
-        if (newKeys.length === 0 && oldKeys.length === 0) {
-            return false;
-        }
-        if (newKeys.length >= oldKeys.length) {
-            let newKeyIndex = 0;
-            let oldKeyIndex = 0;
-            while (newKeyIndex < newKeys.length) {
-                const childPath = path ? `${path}.${newKeys[newKeyIndex]}` : newKeys[newKeyIndex];
-                if (oldKeyIndex < oldKeys.length && newKeys[newKeyIndex] === oldKeys[oldKeyIndex]) {
-                    allChildrenChanged =
-                        JsonDiffRecursive(childPath, newValue[newKeys[newKeyIndex]], oldValue[oldKeys[oldKeyIndex]], resp) &&
-                            allChildrenChanged;
-                    oldKeyIndex++;
-                }
-                else if (newValue[newKeys[newKeyIndex]] !== undefined) {
-                    resp.push({
-                        path: childPath,
-                        value: newValue[newKeys[newKeyIndex]]
-                    });
-                }
-                newKeyIndex++;
+    function UpdateSource(source, path, value, keyFunc) {
+        const diffResult = [];
+        if (keyFunc) {
+            const keyPath = ResolveKeyPath(source, path, keyFunc);
+            if (keyPath !== path) {
+                const keyDiffResult = UpdateSource(source, keyPath, value, keyFunc);
+                diffResult.push(...keyDiffResult);
             }
-            if (oldKeyIndex < oldKeys.length)
-                allChildrenChanged = true;
         }
-        return allChildrenChanged;
-    }
-    function BreakUpValue(path, parent, keyFunc, prop, map) {
-        const value = prop ? parent[prop] : parent;
-        const isValue = IsValue(value);
-        if (!map && isValue)
-            return new Map([[path, value]]);
-        map = map || new Map();
-        if (isValue)
-            return map;
-        const key = keyFunc ? keyFunc(value) : null;
-        const keyRef = key && DiffTree.GetKeyRef(key);
-        if (key && key !== path) {
-            if (prop)
-                parent[prop] = keyRef;
-            BreakUpValue(key, value, keyFunc, null, map);
+        const sourceValue = GetPathValue(source, path);
+        JsonDiff(value, sourceValue, path, diffResult);
+        if (keyFunc) {
+            let flattened = {};
+            flattened = FlattenValue(flattened, value, keyFunc);
+            const keys = Object.keys(flattened);
+            for (let x = 0; x < keys.length; x++)
+                JsonDiff(flattened[keys[x]], source[keys[x]], keys[x], diffResult);
         }
-        else {
-            for (const subProp in value) {
-                const childPath = `${path}.${subProp}`;
-                BreakUpValue(childPath, value, keyFunc, subProp, map);
-            }
+        const filteredDiffResult = diffResult.filter((diff) => diff.value !== undefined);
+        for (let x = 0; x < filteredDiffResult.length; x++) {
+            SetPathValue(source, filteredDiffResult[x].path, filteredDiffResult[x].value);
         }
-        if (!prop)
-            map.set(path, key === path ? value : keyRef || value);
-        return map;
+        return diffResult;
     }
     class DiffTree {
         keyFunc;
-        rootStateMap = new Map();
+        rootState = { root: null };
         constructor(keyFunc) {
             this.keyFunc = keyFunc;
         }
-        static GetKeyRef(key) {
-            return `___DiffTreeKeyRef.${key}`;
-        }
-        static ReadKeyRef(ref) {
-            if (!ref)
-                return undefined;
-            var matches = ref.match(/^___DiffTreeKeyRef\.([^.]+$)/);
-            if (!matches)
-                return undefined;
-            return matches[1];
-        }
         DiffBatch(data) {
-            var resp = [];
-            ;
-            for (var x = 0; x < data.length; x++)
-                this.RunDiff(data[x].path, data[x].value, resp);
-            return resp;
+            const results = data
+                .map(({ path, value }) => this.DiffPath(path, value))
+                .flat(1);
+            return results;
         }
         DiffPath(path, value) {
-            var resp = [];
-            this.RunDiff(path, value, resp);
-            return resp;
-        }
-        UpdatePath(path, value) {
-            this.SetPathValue(path, value);
+            path = (path && `root.${path}`) || "root";
+            return UpdateSource(this.rootState, path, value, this.keyFunc);
         }
         GetPath(path) {
-            return this.GetPathValue(path);
-        }
-        RunDiff(path, value, diffResp) {
-            var breakupMap = this.GetBreakUpMap(path, value);
-            var resp = diffResp || [];
-            breakupMap.forEach((value, key) => {
-                var currentValue = key.split(".").reduce((pre, curr, index) => {
-                    if (index === 0)
-                        return this.rootStateMap.get(curr);
-                    return pre && pre[curr];
-                }, null);
-                JsonDiffRecursive(key, value, currentValue, resp);
-            });
-            for (var x = 0; x < resp.length; x++)
-                this.SetPathValue(resp[x].path, resp[x].value);
-        }
-        GetPathValue(path) {
-            var parts = path.split(".");
-            var curr = this.rootStateMap.get(parts[0]);
-            for (var x = 1; x < parts.length; x++)
-                curr = curr && curr[parts[x]];
-            return curr;
-        }
-        SetPathValue(path, value) {
-            var parts = path.split(".");
-            if (parts.length === 1)
-                this.rootStateMap.set(parts[0], value);
-            else {
-                var curr = this.rootStateMap.get(parts[0]);
-                for (var x = 1; x < parts.length - 1; x++)
-                    curr = curr[parts[x]];
-                curr[parts[parts.length - 1]] = value;
-            }
-        }
-        GetBreakUpMap(path, value) {
-            if (!this.keyFunc)
-                return new Map([[path, value]]);
-            return BreakUpValue(path, value, this.keyFunc);
+            path = (path && `root.${path}`) || "root";
+            return GetPathValue(this.rootState, path);
         }
     }
     return DiffTree;

package/Store/Diff/diffWorker.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiffWorker = void 0;
+const json_1 = require("../../Utils/json");
 const diffTree_1 = require("./diffTree");
 var DiffWorker;
 (function (DiffWorker) {
-    var workerConstructor = null;
-    var workerParameter = null;
-    if (typeof Worker !== 'undefined') {
+    let workerConstructor = null;
+    let workerParameter = null;
+    if (typeof Worker !== "undefined") {
         workerConstructor = Worker;
-        workerParameter = URL.createObjectURL(new Blob([`(${diffTree_1.DiffTreeScope}).call(this, true)`]));
+        workerParameter = URL.createObjectURL(new Blob([`(${diffTree_1.DiffTreeFactory}).call(this, (${json_1.JsonDiffFactory}), true)`]));
     }
     function Create() {
         if (!workerConstructor)

package/Store/Store/store.d.ts

@@ -1,14 +0,0 @@
-import { StoreWriter } from "./storeWriter";
-export declare class Store<T> {
-    private observableTree;
-    private storeWriter;
-    private rootScope;
-    get Root(): import("..").ObservableScope<T>;
-    constructor(init?: T);
-    Action(action: {
-        (root: T, writer: StoreWriter): void;
-    }): void;
-    Write(data: T): void;
-    Merge(data: Partial<T>): void;
-    Destroy(): void;
-}

package/Store/Store/store.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Store = void 0;
-const observableTree_1 = require("../Tree/observableTree");
-const storeWriter_1 = require("./storeWriter");
-class Store {
-    observableTree = new observableTree_1.ObservableTree();
-    storeWriter = new storeWriter_1.StoreWriter(this.observableTree);
-    rootScope = this.observableTree.Scope("ROOT", root => root);
-    get Root() {
-        return this.rootScope;
-    }
-    constructor(init) {
-        if (init)
-            this.Write(init);
-    }
-    Action(action) {
-        var proxy = this.observableTree.Get("ROOT");
-        action(proxy, this.storeWriter);
-    }
-    Write(data) {
-        this.Action((root, writer) => writer.Write(root, data));
-    }
-    Merge(data) {
-        this.Action((root, writer) => writer.Merge(root, data));
-    }
-    Destroy() {
-        this.rootScope.Destroy();
-    }
-}
-exports.Store = Store;

package/Store/Store/storeAsync.d.ts

@@ -1,20 +0,0 @@
-import { StoreAsyncWriter } from "./storeAsyncWriter";
-export declare class StoreAsync {
-    private idFunc;
-    private diffAsync;
-    private observableTree;
-    private asyncWriter;
-    private asyncQueue;
-    constructor(idFunc: {
-        (val: any): string;
-    }, init?: any);
-    Scope<T, R>(id: string, func: {
-        (val: T): R;
-    }): import("..").ObservableScope<T | R>;
-    Action<T>(id: string, action: {
-        (val: T, writer: StoreAsyncWriter): Promise<void>;
-    }): Promise<void>;
-    Write(data: any): Promise<void>;
-    Merge(id: string, data: any): Promise<void>;
-    Destroy(): void;
-}

package/Store/Store/storeAsync.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreAsync = void 0;
-const observableTree_1 = require("../Tree/observableTree");
-const diffAsync_1 = require("../Diff/diffAsync");
-const storeAsyncWriter_1 = require("./storeAsyncWriter");
-const asyncQueue_1 = require("../../Utils/asyncQueue");
-class StoreAsync {
-    idFunc;
-    diffAsync;
-    observableTree;
-    asyncWriter;
-    asyncQueue;
-    constructor(idFunc, init) {
-        this.idFunc = idFunc;
-        this.diffAsync = new diffAsync_1.DiffAsync(this.idFunc);
-        this.observableTree = new observableTree_1.ObservableTree(diffAsync_1.DiffAsync.ReadKeyRef);
-        this.asyncWriter = new storeAsyncWriter_1.StoreAsyncWriter(this.idFunc, this.diffAsync, this.observableTree);
-        this.asyncQueue = new asyncQueue_1.AsyncQueue();
-        if (init) {
-            var id = this.idFunc(init);
-            this.observableTree.Write(id, init);
-            this.Write(init);
-        }
-    }
-    Scope(id, func) {
-        return this.observableTree.Scope(id, func);
-    }
-    async Action(id, action) {
-        await this.asyncQueue.Next(async () => {
-            await action(id && this.observableTree.Get(id), this.asyncWriter);
-        });
-    }
-    async Write(data) {
-        await this.Action(null, async (val, writer) => {
-            await writer.Write(val, data);
-        });
-    }
-    async Merge(id, data) {
-        await this.Action(id, async (val, writer) => {
-            await writer.Merge(val, data);
-        });
-    }
-    Destroy() {
-        this.asyncQueue.Stop();
-        this.diffAsync.Destroy();
-    }
-}
-exports.StoreAsync = StoreAsync;