j-templates 7.0.0 → 7.0.3

package/DOM/createEventAssignment.d.ts

@@ -1 +1,4 @@
 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,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateEventAssignment = CreateEventAssignment;
+exports.AssignEvents = AssignEvents;
 function CreateEventAssignment(target, event) {
     let lastEvent;
     return function (next) {
@@ -12,3 +13,8 @@ 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/domNodeConfig.js

@@ -119,6 +119,9 @@ exports.DOMNodeConfig = {
     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);
     },
@@ -139,8 +142,6 @@ exports.DOMNodeConfig = {
         target.replaceChildren(...children);
     },
     reconcileChildren(target, children) {
-        if (children.length === 0 && !target.firstChild)
-            return;
         if (children.length === 0 || !target.firstChild) {
             target.replaceChildren(...children);
             return;

package/Node/nodeConfig.d.ts

@@ -32,6 +32,7 @@ export interface INodeConfig {
             [event: string]: (event: Event) => void;
         }): void;
     };
+    assignEvents(target: any, next: any): void;
     createAttributeAssignment(target: any): {
         (next: {
             [attribute: string]: string;

package/Node/vNode.js

@@ -15,16 +15,13 @@ var vNode;
             node: null,
             children: null,
             destroyed: false,
-            assignProperties: null,
-            assignEvents: null,
-            assignAttributes: null,
             component: null,
             scopes: []
         };
     }
     vNode.Create = Create;
     function Init(vnode) {
-        if (vnode.node !== null)
+        if (vnode.definition === null)
             return;
         InitNode(vnode);
     }
@@ -38,7 +35,6 @@ var vNode;
         if (vnode.destroyed)
             return;
         vnode.destroyed = true;
-        vnode.assignEvents?.(null);
         vnode.component?.Destroy();
         Store_1.ObservableScope.DestroyAll(vnode.scopes);
         vnode.children && DestroyAll(vnode.children);
@@ -69,56 +65,43 @@ var vNode;
 })(vNode || (exports.vNode = vNode = {}));
 function InitNode(vnode) {
     const { type, namespace, props, attrs, on, data, componentConstructor, children, childrenArray } = vnode.definition;
-    const node = nodeConfig_1.NodeConfig.createNode(type, namespace);
-    vnode.node = node;
+    const node = vnode.node = nodeConfig_1.NodeConfig.createNode(type, namespace);
+    vnode.definition = null;
     if (props) {
-        vnode.assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
+        const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
         if (typeof props === 'function') {
             const scope = Store_1.ObservableScope.Create(props);
             vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, CreateScheduledCallback(function () {
-                const value = Store_1.ObservableScope.Peek(scope);
-                vnode.assignProperties(value);
-            }));
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignProperties));
             const value = Store_1.ObservableScope.Peek(scope);
-            vnode.assignProperties(value);
-        }
-        else {
-            vnode.assignProperties(props);
-            vnode.assignProperties = null;
+            assignProperties(value);
         }
+        else
+            assignProperties(props);
     }
     if (on) {
-        vnode.assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
+        const assignEvents = nodeConfig_1.NodeConfig.createEventAssignment(node);
         if (typeof on === 'function') {
             const scope = Store_1.ObservableScope.Create(on);
             vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, CreateScheduledCallback(function () {
-                const value = Store_1.ObservableScope.Peek(scope);
-                vnode.assignEvents(value);
-            }));
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignEvents));
             const value = Store_1.ObservableScope.Peek(scope);
-            vnode.assignEvents(value);
+            assignEvents(value);
         }
         else
-            vnode.assignEvents(on);
+            assignEvents(on);
     }
     if (attrs) {
-        vnode.assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
+        const assignAttributes = nodeConfig_1.NodeConfig.createAttributeAssignment(node);
         if (typeof attrs === 'function') {
             const scope = Store_1.ObservableScope.Create(attrs);
             vnode.scopes.push(scope);
-            Store_1.ObservableScope.Watch(scope, CreateScheduledCallback(function () {
-                const value = Store_1.ObservableScope.Peek(scope);
-                vnode.assignAttributes(value);
-            }));
+            Store_1.ObservableScope.Watch(scope, ScheduledAssignment(assignAttributes));
             const value = Store_1.ObservableScope.Peek(scope);
-            vnode.assignAttributes(value);
-        }
-        else {
-            vnode.assignAttributes(attrs);
-            vnode.assignAttributes = null;
+            assignAttributes(value);
         }
+        else
+            assignAttributes(attrs);
     }
     if (componentConstructor) {
         vnode.component = new componentConstructor(vnode);
@@ -286,6 +269,19 @@ function ToArray(callback) {
         return [result];
     };
 }
+function ScheduledAssignment(assign) {
+    let scheduled = false;
+    return function (scope) {
+        if (scheduled)
+            return;
+        scheduled = true;
+        nodeConfig_1.NodeConfig.scheduleUpdate(function () {
+            scheduled = false;
+            const value = Store_1.ObservableScope.Peek(scope);
+            assign(value);
+        });
+    };
+}
 function CreateScheduledCallback(callback) {
     let scheduled = false;
     return function () {

package/Node/vNode.types.d.ts

@@ -18,13 +18,6 @@ export type vNode = {
     node: Node | null;
     children: vNode[] | null;
     destroyed: boolean;
-    assignProperties: (next: any) => void;
-    assignEvents: (next: {
-        [event: string]: (event: Event) => void;
-    }) => void;
-    assignAttributes: (next: {
-        [attr: string]: string;
-    }) => void;
     scopes: IObservableScope<unknown>[];
     component: Component;
 };

package/Store/Tree/observableScope.js

@@ -77,8 +77,8 @@ function CalcScope(callback) {
             async: valueFunction[Symbol.toStringTag] === "AsyncFunction",
             dirty: true,
             emitter: emitter_1.Emitter.Create(),
-            emitters: [],
-            calcFunctions: [],
+            emitters: null,
+            calcFunctions: null,
             onDestroyed: null,
             destroyed: false,
             setCallback: function () {
@@ -153,16 +153,15 @@ function CalcScope(callback) {
     }
     ObservableScope.DestroyAll = DestroyAll;
 })(ObservableScope || (exports.ObservableScope = ObservableScope = {}));
-function CalcChanged(calc) {
-    const value = calc.getFunction();
-    const changed = calc.value !== value;
-    calc.value = value;
-    return changed;
-}
 function DirtyScope(scope) {
     if (scope.dirty || !scope.getFunction)
         return;
-    scope.dirty = scope.calcFunctions.length === 0 || scope.calcFunctions.some(CalcChanged);
+    let dirty = scope.calcFunctions.length === 0;
+    for (let x = 0; !dirty && x < scope.calcFunctions.length; x++) {
+        const calc = scope.calcFunctions[x];
+        dirty = dirty || calc.value !== calc.getFunction();
+    }
+    scope.dirty = dirty;
     if (!scope.dirty)
         return;
     if (scope.async) {
@@ -209,6 +208,12 @@ function UpdateValue(scope) {
     UpdateEmitters(scope, emitters);
 }
 function UpdateEmitters(scope, right) {
+    if (scope.emitters === null) {
+        for (let x = 0; x < right.length; x++)
+            emitter_1.Emitter.On(right[x], scope.setCallback);
+        scope.emitters = right;
+        return;
+    }
     if (right.length === 0) {
         if (scope.emitters.length > 0) {
             for (let x = 0; x < scope.emitters.length; x++)

package/Utils/animation.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Animation = exports.AnimationType = void 0;
-const domNodeConfig_1 = require("../DOM/domNodeConfig");
+const nodeConfig_1 = require("../Node/nodeConfig");
 var StepFunctions;
 (function (StepFunctions) {
     function EaseIn(start, duration) {
@@ -47,7 +47,7 @@ class Animation {
         this.enabled = true;
         this.type = type;
         this.animationDuration = duration;
-        this.animationUpdate = domNodeConfig_1.DOMNodeConfig.wrapPriorityUpdates(update);
+        this.animationUpdate = nodeConfig_1.NodeConfig.wrapPriorityUpdates(update);
     }
     Animate(start, end) {
         if (!this.enabled)
@@ -70,13 +70,13 @@ class Animation {
                 const next = this.start + step;
                 this.animationUpdate(next);
                 if (percent < 1)
-                    domNodeConfig_1.DOMNodeConfig.scheduleUpdate(this.animationRun);
+                    nodeConfig_1.NodeConfig.scheduleUpdate(this.animationRun);
                 else {
                     resolve();
                 }
             };
             this.animationRun = animationRun;
-            domNodeConfig_1.DOMNodeConfig.scheduleUpdate(this.animationRun);
+            nodeConfig_1.NodeConfig.scheduleUpdate(this.animationRun);
         }).then(() => {
             this.Cancel();
         });

package/Utils/list.js

@@ -3,35 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.List = void 0;
 var List;
 (function (List) {
-    let maxTempListSize = 0;
-    let trimScheduled = false;
-    const tempList = Create();
     function CreateNode(data) {
-        const node = PopNode(tempList) ?? { previous: null, next: null, data: null };
-        node.data = data;
-        return node;
-    }
-    function TrimTempList() {
-        trimScheduled = false;
-        if (maxTempListSize < tempList.size)
-            maxTempListSize = tempList.size;
-        const trimSize = Math.floor(maxTempListSize / 10);
-        Split(tempList, trimSize);
-    }
-    function ScheduleTrimTempList() {
-        if (!trimScheduled && tempList.size > maxTempListSize) {
-            trimScheduled = true;
-            requestIdleCallback(TrimTempList);
-        }
-    }
-    function ReturnNode(node) {
-        if (!node)
-            return;
-        node.previous = null;
-        node.next = null;
-        node.data = null;
-        AddNode(tempList, node);
-        ScheduleTrimTempList();
+        return { previous: null, next: null, data };
     }
     function Create() {
         return {
@@ -65,13 +38,9 @@ var List;
     }
     List.Split = Split;
     function Clear(list) {
-        let node = list.head;
-        while (node) {
-            node.data = null;
-            node = node.next;
-        }
-        Append(tempList, list);
-        ScheduleTrimTempList();
+        list.head = null;
+        list.tail = null;
+        list.size = 0;
     }
     List.Clear = Clear;
     function Push(list, data) {
@@ -108,7 +77,6 @@ var List;
     function Pop(list) {
         const node = PopNode(list);
         const data = node?.data;
-        ReturnNode(node);
         return data;
     }
     List.Pop = Pop;
@@ -177,7 +145,6 @@ var List;
         if (list.size === 0)
             list.head = null;
         const data = node.data;
-        ReturnNode(node);
         return data;
     }
     List.Remove = Remove;

package/package.json

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