j-templates 5.0.46 → 5.0.47

package/Store/Diff/diffSync.d.ts

@@ -1,14 +1,14 @@
-export declare class DiffSync {
-    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;
-    DiffBatch(data: Array<{
-        path: string;
-        value: any;
-    }>): import("./diffTree").IDiffResponse;
-    UpdatePath(path: string, value: any): void;
-}
+export declare class DiffSync {
+    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;
+    DiffBatch(data: Array<{
+        path: string;
+        value: any;
+    }>): import("./diffTree").IDiffResponse;
+    UpdatePath(path: string, value: any): void;
+}

package/Store/Diff/diffSync.js

@@ -1,27 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffSync = void 0;
-const diffTree_1 = require("./diffTree");
-const diffCnstr = (0, diffTree_1.DiffTreeScope)();
-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) {
-        return this.diffTree.DiffPath(path, value);
-    }
-    DiffBatch(data) {
-        return this.diffTree.DiffBatch(data);
-    }
-    UpdatePath(path, value) {
-        this.diffTree.UpdatePath(path, value);
-    }
-}
-exports.DiffSync = DiffSync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffSync = void 0;
+const diffTree_1 = require("./diffTree");
+const diffCnstr = (0, diffTree_1.DiffTreeScope)();
+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) {
+        return this.diffTree.DiffPath(path, value);
+    }
+    DiffBatch(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,24 @@
-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;
-}
-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 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;
+}
+export interface IDiffTreeConstructor {
+    new (keyFunc?: {
+        (val: any): string;
+    }): IDiffTree;
+    GetKeyRef(key: string): string;
+    ReadKeyRef(ref: string): string;
+}
+export declare function DiffTreeScope(worker?: boolean): IDiffTreeConstructor;

package/Store/Diff/diffTree.js

@@ -1,221 +1,232 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffTreeScope = void 0;
-function DiffTreeScope(worker) {
-    const ctx = this;
-    if (ctx && worker) {
-        let diffTree = null;
-        ctx.onmessage = function (event) {
-            var data = event.data;
-            switch (data.method) {
-                case "create":
-                    var 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]);
-                    ctx.postMessage(diff);
-                    break;
-                case "diffbatch":
-                    var 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]);
-                    ctx.postMessage(ret);
-                    break;
-            }
-        };
-    }
-    const jsonConstructor = {}.constructor;
-    function IsValue(value) {
-        if (!value)
-            return true;
-        return !(jsonConstructor === value.constructor || Array.isArray(value));
-    }
-    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;
-    }
-    class DiffTree {
-        keyFunc;
-        rootStateMap = new Map();
-        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;
-        }
-        DiffPath(path, value) {
-            var resp = [];
-            this.RunDiff(path, value, resp);
-            return resp;
-        }
-        UpdatePath(path, value) {
-            this.SetPathValue(path, value);
-        }
-        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);
-                this.DiffJson(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 this.BreakUpValue(path, value);
-        }
-        BreakUpValue(path, parent, prop, map) {
-            var value = prop ? parent[prop] : parent;
-            var isValue = IsValue(value);
-            if (!map && isValue)
-                return new Map([[path, value]]);
-            map = map || new Map();
-            if (isValue)
-                return map;
-            var key = this.keyFunc ? this.keyFunc(value) : null;
-            var keyRef = key && DiffTree.GetKeyRef(key);
-            if (key && key !== path) {
-                if (prop)
-                    parent[prop] = keyRef;
-                this.BreakUpValue(key, value, null, map);
-            }
-            else {
-                for (var subProp in value) {
-                    var childPath = `${path}.${subProp}`;
-                    this.BreakUpValue(childPath, value, subProp, map);
-                }
-            }
-            if (!prop)
-                map.set(path, key === path ? value : keyRef || value);
-            return map;
-        }
-        DiffJson(path, newValue, oldValue, resp) {
-            const newType = TypeOf(newValue);
-            const oldType = TypeOf(oldValue);
-            if (newType !== oldType) {
-                resp.push({
-                    path,
-                    value: newValue
-                });
-                return true;
-            }
-            if (newType === Type.Value || oldType === Type.Value) {
-                if (newValue !== oldValue) {
-                    resp.push({
-                        path,
-                        value: newValue
-                    });
-                    return true;
-                }
-                return false;
-            }
-            const changedPathLength = resp.length;
-            let allChildrenChanged = true;
-            if (newType === Type.Array) {
-                if (newValue.length !== oldValue.length)
-                    resp.push({
-                        path: path ? `${path}.length` : 'length',
-                        value: newValue.length
-                    });
-                for (let y = 0; y < newValue.length; y++) {
-                    const arrayPath = path ? `${path}.${y}` : `${y}`;
-                    allChildrenChanged = this.DiffJson(arrayPath, newValue[y], oldValue[y], resp) && allChildrenChanged;
-                }
-            }
-            else if (newType === Type.Object) {
-                const newKeys = Object.keys(newValue).sort();
-                const oldKeys = Object.keys(oldValue).sort();
-                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 = this.DiffJson(childPath, newValue[newKeys[newKeyIndex]], oldValue[oldKeys[oldKeyIndex]], resp) && allChildrenChanged;
-                            oldKeyIndex++;
-                        }
-                        else {
-                            resp.push({
-                                path: childPath,
-                                value: newValue[newKeys[newKeyIndex]]
-                            });
-                        }
-                        newKeyIndex++;
-                    }
-                }
-            }
-            if (path && allChildrenChanged) {
-                resp.splice(changedPathLength);
-                resp.push({
-                    path,
-                    value: newValue
-                });
-                return true;
-            }
-            return false;
-        }
-    }
-    return DiffTree;
-}
-exports.DiffTreeScope = DiffTreeScope;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffTreeScope = void 0;
+function DiffTreeScope(worker) {
+    const ctx = this;
+    if (ctx && worker) {
+        let diffTree = null;
+        ctx.onmessage = function (event) {
+            var data = event.data;
+            switch (data.method) {
+                case "create":
+                    var 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]);
+                    ctx.postMessage(diff);
+                    break;
+                case "diffbatch":
+                    var 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]);
+                    ctx.postMessage(ret);
+                    break;
+            }
+        };
+    }
+    const jsonConstructor = {}.constructor;
+    function IsValue(value) {
+        if (!value)
+            return true;
+        return !(jsonConstructor === value.constructor || Array.isArray(value));
+    }
+    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 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 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 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++;
+            }
+            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);
+        }
+        else {
+            for (const subProp in value) {
+                const childPath = `${path}.${subProp}`;
+                BreakUpValue(childPath, value, keyFunc, subProp, map);
+            }
+        }
+        if (!prop)
+            map.set(path, key === path ? value : keyRef || value);
+        return map;
+    }
+    class DiffTree {
+        keyFunc;
+        rootStateMap = new Map();
+        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;
+        }
+        DiffPath(path, value) {
+            var resp = [];
+            this.RunDiff(path, value, resp);
+            return resp;
+        }
+        UpdatePath(path, value) {
+            this.SetPathValue(path, value);
+        }
+        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);
+        }
+    }
+    return DiffTree;
+}
+exports.DiffTreeScope = DiffTreeScope;

package/Store/Diff/diffWorker.d.ts

@@ -1,3 +1,3 @@
-export declare namespace DiffWorker {
-    function Create(): Worker;
-}
+export declare namespace DiffWorker {
+    function Create(): Worker;
+}

package/Store/Diff/diffWorker.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffWorker = void 0;
-const diffTree_1 = require("./diffTree");
-var DiffWorker;
-(function (DiffWorker) {
-    var workerConstructor = null;
-    var workerParameter = null;
-    if (typeof Worker !== 'undefined') {
-        workerConstructor = Worker;
-        workerParameter = URL.createObjectURL(new Blob([`(${diffTree_1.DiffTreeScope}).call(this, true)`]));
-    }
-    function Create() {
-        if (!workerConstructor)
-            throw "Worker is not available";
-        return new workerConstructor(workerParameter);
-    }
-    DiffWorker.Create = Create;
-})(DiffWorker = exports.DiffWorker || (exports.DiffWorker = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffWorker = void 0;
+const diffTree_1 = require("./diffTree");
+var DiffWorker;
+(function (DiffWorker) {
+    var workerConstructor = null;
+    var workerParameter = null;
+    if (typeof Worker !== 'undefined') {
+        workerConstructor = Worker;
+        workerParameter = URL.createObjectURL(new Blob([`(${diffTree_1.DiffTreeScope}).call(this, true)`]));
+    }
+    function Create() {
+        if (!workerConstructor)
+            throw "Worker is not available";
+        return new workerConstructor(workerParameter);
+    }
+    DiffWorker.Create = Create;
+})(DiffWorker || (exports.DiffWorker = DiffWorker = {}));