j-templates 7.0.53 → 7.0.54

package/DOM/createAssignment.js

@@ -8,13 +8,14 @@ function CreateAssignment(target, createAssignment) {
         if (next === last)
             return;
         last = next;
-        const nextKeys = next && Object.keys(next);
-        for (let x = 0; nextKeys && x < nextKeys.length; x++) {
-            const key = nextKeys[x];
-            writeTo[key] ??= createAssignment(target, key);
+        for (const key in writeTo) {
+            writeTo[key](next);
+        }
+        for (const key in next) {
+            if (!Object.hasOwn(writeTo, key)) {
+                writeTo[key] = createAssignment(target, key);
+                writeTo[key](next);
+            }
         }
-        const writeFunctions = Object.values(writeTo);
-        for (let x = 0; x < writeFunctions.length; x++)
-            writeFunctions[x](next);
     };
 }

package/DOM/createEventAssignment.d.ts

@@ -1,4 +1 @@
 export declare function CreateEventAssignment(target: HTMLElement, event: string): (next: any) => void;
-export declare function AssignEvents(target: HTMLElement, eventMap: {
-    [event: string]: any;
-}): void;

package/DOM/createEventAssignment.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateEventAssignment = CreateEventAssignment;
-exports.AssignEvents = AssignEvents;
 function CreateEventAssignment(target, event) {
     let lastEvent;
     return function (next) {
@@ -13,8 +12,3 @@ function CreateEventAssignment(target, event) {
         lastEvent = nextEvent;
     };
 }
-function AssignEvents(target, eventMap) {
-    const entries = Object.entries(eventMap);
-    for (let x = 0; x < entries.length; x++)
-        target.addEventListener(entries[x][0], entries[x][1]);
-}

package/DOM/createPropertyAssignment.d.ts

@@ -1,7 +1 @@
-export declare function CreateNodeValueAssignment(target: HTMLElement): (value: string) => void;
-export declare function CreatePropertyAssignment(target: any): ((next: {
-    nodeValue: string;
-}) => void) | ((next: {
-    [prop: string]: any;
-}) => void);
-export declare function AssignProperties(target: any, next: any): void;
+export declare function CreateRootPropertyAssignment(target: HTMLElement, property: string): (next: any) => void;

package/DOM/createPropertyAssignment.js

@@ -1,34 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateNodeValueAssignment = CreateNodeValueAssignment;
-exports.CreatePropertyAssignment = CreatePropertyAssignment;
-exports.AssignProperties = AssignProperties;
+exports.CreateRootPropertyAssignment = CreateRootPropertyAssignment;
 const json_1 = require("../Utils/json");
-function CreateNodeValueAssignment(target) {
-    let lastValue = target.nodeValue;
-    return function AssignNodeValue(value) {
-        if (value !== lastValue) {
-            target.nodeValue = value;
-            lastValue = value;
+const createAssignment_1 = require("./createAssignment");
+function CreatePropertyAssignment(target, property) {
+    let lastValue;
+    let jsonType;
+    let childAssignment;
+    return function (next) {
+        const nextValue = next && next[property];
+        if (nextValue === lastValue)
+            return;
+        jsonType ??= (0, json_1.JsonType)(nextValue);
+        switch (jsonType) {
+            case "value":
+                target[property] = nextValue;
+                break;
+            default: {
+                const childTarget = target[property];
+                childAssignment ??= (0, createAssignment_1.CreateAssignment)(childTarget, CreateRootPropertyAssignment);
+                childAssignment(nextValue);
+            }
         }
     };
 }
-function WalkValue(next, callback, index = 0, parent = "") {
-    const entries = Object.entries(next);
-    for (let x = 0; x < entries.length; x++) {
-        const [key, value] = entries[x];
-        const type = (0, json_1.JsonType)(value);
-        switch (type) {
-            case "object":
-                index = WalkValue(value, callback, index, `${parent}${key}.`);
+function CreateRootPropertyAssignment(target, property) {
+    let lastValue;
+    let jsonType;
+    let childAssignment;
+    return function (next) {
+        const nextValue = next && next[property];
+        if (nextValue === lastValue)
+            return;
+        switch (property) {
+            case "nodeValue": {
+                AssignNodeValue(target, nextValue);
+                break;
+            }
+            case "className": {
+                AssignClassName(target, nextValue);
                 break;
-            default:
-                callback(`${parent}${key}`, value, index);
-                index++;
+            }
+            case "value": {
+                AssignValue(target, nextValue);
                 break;
+            }
+            default: {
+                jsonType ??= (0, json_1.JsonType)(nextValue);
+                switch (jsonType) {
+                    case "value":
+                        target[property] = nextValue;
+                        break;
+                    default: {
+                        const childTarget = target[property];
+                        childAssignment ??= (0, createAssignment_1.CreateAssignment)(childTarget, CreatePropertyAssignment);
+                        childAssignment(nextValue);
+                    }
+                }
+            }
         }
-    }
-    return index;
+    };
 }
 function AssignNodeValue(target, value) {
     target.nodeValue = value;
@@ -43,53 +74,3 @@ function AssignValue(target, value) {
 function AssignClassName(target, value) {
     target.className = value;
 }
-function GetAssignmentFunction(path) {
-    switch (path) {
-        case "nodeValue":
-            return AssignNodeValue;
-        case "value":
-            return AssignValue;
-        case "className":
-            return AssignClassName;
-        default:
-            return new Function("t", "v", `t.${path} = v;`);
-    }
-}
-function CreatePropertyAssignment(target) {
-    if (target.nodeType === Node.TEXT_NODE) {
-        return function (next) {
-            AssignNodeValue(target, next.nodeValue);
-        };
-    }
-    const last = [
-        ["", null, null],
-    ];
-    function WalkCallback(path, value, index) {
-        if (index >= last.length || last[index][0] !== path) {
-            last[index] = [path, value, GetAssignmentFunction(path)];
-            last[index][2](target, value);
-        }
-        else if (last[index][1] !== value) {
-            last[index][1] = value;
-            last[index][2](target, value);
-        }
-    }
-    return function AssignProperty(next) {
-        if (next === null) {
-            for (let x = 0; x < last.length; x++)
-                last[x][2] !== null && last[x][2](target, null);
-            if (last.length > 0)
-                last.splice(0);
-            return;
-        }
-        const endIndex = WalkValue(next, WalkCallback);
-        if (endIndex < last.length)
-            last.splice(endIndex);
-    };
-}
-function AssignProperties(target, next) {
-    WalkValue(next, function (path, value) {
-        const assignment = GetAssignmentFunction(path);
-        assignment(target, value);
-    });
-}

package/DOM/domNodeConfig.js

@@ -6,7 +6,6 @@ const list_1 = require("../Utils/list");
 const createPropertyAssignment_1 = require("./createPropertyAssignment");
 const createEventAssignment_1 = require("./createEventAssignment");
 const createAssignment_1 = require("./createAssignment");
-const createPropertyAssignment_2 = require("./createPropertyAssignment");
 const createAttributeAssignment_1 = require("./createAttributeAssignment");
 let pendingUpdates = list_1.List.Create();
 let updateScheduled = false;
@@ -98,9 +97,6 @@ exports.DOMNodeConfig = {
     remove(target) {
         target && target.parentNode && target.parentNode.removeChild(target);
     },
-    createTextAssignment(target) {
-        return (0, createPropertyAssignment_1.CreateNodeValueAssignment)(target);
-    },
     setText(target, text) {
         target.nodeValue = text;
     },
@@ -111,17 +107,11 @@ exports.DOMNodeConfig = {
         target.setAttribute(attribute, value);
     },
     createPropertyAssignment(target) {
-        return (0, createPropertyAssignment_2.CreatePropertyAssignment)(target);
-    },
-    assignProperties(target, next) {
-        (0, createPropertyAssignment_1.AssignProperties)(target, next);
+        return (0, createAssignment_1.CreateAssignment)(target, createPropertyAssignment_1.CreateRootPropertyAssignment);
     },
     createEventAssignment(target) {
         return (0, createAssignment_1.CreateAssignment)(target, createEventAssignment_1.CreateEventAssignment);
     },
-    assignEvents(target, next) {
-        (0, createEventAssignment_1.AssignEvents)(target, next);
-    },
     createAttributeAssignment(target) {
         return (0, createAssignment_1.CreateAssignment)(target, createAttributeAssignment_1.CreateAttributeAssignment);
     },

package/Node/nodeConfig.d.ts

@@ -20,19 +20,14 @@ export interface INodeConfig {
     removeChild(root: any, child: any): void;
     remove(target: any): void;
     fireEvent(target: any, event: string, data: any): void;
-    createTextAssignment(target: any): {
-        (next: string): void;
-    };
     createPropertyAssignment(target: any): {
         (next: any): void;
     };
-    assignProperties(target: any, next: any): void;
     createEventAssignment(target: any): {
         (next: {
             [event: string]: (event: Event) => void;
         }): void;
     };
-    assignEvents(target: any, next: any): void;
     createAttributeAssignment(target: any): {
         (next: {
             [attribute: string]: string;

package/Store/Tree/observableScope.js

@@ -56,9 +56,11 @@ function WatchScope(scope) {
     const emitters = watchState[0];
     UpdateEmitters(scope, emitters);
     const calcScopes = watchState[1];
-    const calcScopeValues = calcScopes && Object.values(calcScopes);
-    for (let x = 0; calcScopeValues && x < calcScopeValues.length; x++)
-        calcScopeValues[x] && ObservableScope.Destroy(calcScopeValues[x]);
+    if (calcScopes) {
+        const calcScopeValues = Object.values(calcScopes);
+        for (let x = 0; x < calcScopeValues.length; x++)
+            calcScopeValues[x] && ObservableScope.Destroy(calcScopeValues[x]);
+    }
     scope.calcScopes = watchState[2];
     watchState = parent;
     return value;
@@ -175,7 +177,7 @@ function DirtyScope(scope) {
     else if (scope.calc) {
         const startValue = scope.value;
         UpdateValue(scope);
-        startValue !== scope.value && emitter_1.Emitter.Emit(scope.emitter);
+        startValue !== scope.value && emitter_1.Emitter.Emit(scope.emitter, scope);
     }
     else
         emitter_1.Emitter.Emit(scope.emitter, scope);

package/Utils/emitter.js

@@ -19,16 +19,14 @@ var Emitter;
     }
     Emitter.On = On;
     function Emit(emitter, ...args) {
-        let removed = false;
+        let writePos = 1;
         for (let x = 1; x < emitter.length; x++) {
-            if (emitter[x] === null ||
-                emitter[x](...args) === true) {
-                removed = true;
-                emitter[x] = null;
-            }
+            if (emitter[x] !== null &&
+                emitter[x](...args) !== true)
+                emitter[writePos++] = emitter[x];
         }
-        if (removed)
-            (0, array_1.RemoveNulls)(emitter);
+        if (writePos < emitter.length)
+            emitter.splice(writePos);
     }
     Emitter.Emit = Emit;
     function Remove(emitter, callback) {
@@ -49,31 +47,27 @@ var Emitter;
     Emitter.Distinct = Distinct;
     function DistinctSmall(emitters) {
         Sort(emitters);
-        let lastId = emitters[0][0];
-        let remove = false;
+        let writePos = 1;
         for (let x = 1; x < emitters.length; x++) {
-            const id = emitters[x][0];
-            if (lastId === emitters[x][0]) {
-                emitters[x] = null;
-                remove = true;
+            if (emitters[x][0] !== emitters[writePos - 1][0]) {
+                emitters[writePos++] = emitters[x];
             }
-            lastId = id;
         }
-        remove && (0, array_1.RemoveNulls)(emitters);
+        if (writePos < emitters.length)
+            emitters.splice(writePos);
     }
     function DistinctLarge(emitters) {
-        let remove = false;
+        let writePos = 0;
         const ids = new Set();
         for (let x = 0; x < emitters.length; x++) {
             const id = emitters[x][0];
-            if (!ids.has(id))
+            if (!ids.has(id)) {
                 ids.add(id);
-            else {
-                emitters[x] = null;
-                remove = true;
+                emitters[writePos++] = emitters[x];
             }
         }
-        remove && (0, array_1.RemoveNulls)(emitters);
+        if (writePos < emitters.length)
+            emitters.splice(writePos);
         Sort(emitters);
     }
     function Sort(emitters) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "j-templates",
-  "version": "7.0.53",
+  "version": "7.0.54",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",