j-templates 7.0.31 → 7.0.32

package/Node/vNode.js

@@ -6,11 +6,16 @@ const injector_1 = require("../Utils/injector");
 const list_1 = require("../Utils/list");
 const thread_1 = require("../Utils/thread");
 const nodeConfig_1 = require("./nodeConfig");
+const DEFAULT_VNODE_ARRAY = [undefined];
+function DEFAULT_VNODE_DATA() {
+    return DEFAULT_VNODE_ARRAY;
+}
 var vNode;
 (function (vNode) {
     function Create(definition) {
         return {
             definition,
+            type: definition.type,
             injector: injector_1.Injector.Current() ?? new injector_1.Injector(),
             node: null,
             children: null,
@@ -133,48 +138,100 @@ function InitNode(vnode) {
         vNode.InitAll(vnode.children);
     }
     else if (children) {
-        if (data) {
-            DynamicChildren(vnode, children, ToArray(data));
-        }
-        else
-            StaticChildren(vnode, children);
+        Children(vnode, children, data ? ToArray(data) : DEFAULT_VNODE_DATA);
     }
     UpdateChildren(vnode, true, !!childrenArray);
 }
-function StaticChildren(vnode, children) {
-    const childrenScope = Store_1.ObservableScope.Create(WrapStaticChildren(vnode.injector, children));
+function Children(vnode, children, data) {
+    const nodeList = list_1.List.Create();
+    const childrenScope = Store_1.ObservableScope.Create(WrapChildren(vnode.injector, children, data, nodeList));
+    Store_1.ObservableScope.OnDestroyed(childrenScope, function () {
+        DestroyNodeList(nodeList);
+    });
     vnode.scopes.push(childrenScope);
-    const child = Store_1.ObservableScope.Peek(childrenScope);
-    switch (typeof child) {
+    Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
+        if (vnode.destroyed)
+            return;
+        AssignChildren(vnode, scope);
+        UpdateChildren(vnode);
+    }));
+    AssignChildren(vnode, childrenScope);
+}
+function AssignChildren(vnode, childrenScope) {
+    const children = Store_1.ObservableScope.Value(childrenScope);
+    switch (typeof children) {
         case 'string': {
-            const node = injector_1.Injector.Scope(vnode.injector, vNode.Create, {
-                type: "text",
-                namespace: null,
-                props() {
-                    return { nodeValue: Store_1.ObservableScope.Value(childrenScope) };
-                },
-            });
-            vnode.children = [node];
+            if (vnode.children?.[0]?.type !== 'text') {
+                vnode.children && vNode.DestroyAll(vnode.children);
+                const node = injector_1.Injector.Scope(vnode.injector, vNode.Create, {
+                    type: "text",
+                    namespace: null,
+                    props() {
+                        return { nodeValue: Store_1.ObservableScope.Value(childrenScope) };
+                    },
+                });
+                vnode.children = [node];
+            }
             break;
         }
         default: {
-            Store_1.ObservableScope.Touch(childrenScope);
-            Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function () {
-                if (vnode.destroyed)
-                    return;
-                vNode.DestroyAll(vnode.children);
-                const nodes = Store_1.ObservableScope.Peek(childrenScope);
-                vnode.children = Array.isArray(nodes) ? nodes : [nodes];
-                UpdateChildren(vnode);
-            }));
-            vnode.children = (Array.isArray(child) ? child : [child]);
+            vnode.children = Array.isArray(children) ? children : [children];
             break;
         }
     }
 }
-function WrapStaticChildren(injector, children) {
+function WrapChildren(injector, children, data, nodeList) {
     return function () {
-        return injector_1.Injector.Scope(injector, children, undefined);
+        const nextData = data();
+        switch (nextData.length) {
+            case 0:
+                DestroyNodeList(nodeList);
+                return [];
+            case 1:
+                DestroyNodeList(nodeList);
+                return injector_1.Injector.Scope(injector, children, nextData[0]);
+            default: {
+                const nodeListMap = list_1.List.ToListMap(nodeList, GetData);
+                const nextNodeList = list_1.List.Create();
+                const nextNodeArray = [];
+                for (let x = 0; x < nextData.length; x++) {
+                    const data = nextData[x];
+                    const existingNodeList = nodeListMap.get(data);
+                    const existingNode = existingNodeList && list_1.List.PopNode(existingNodeList);
+                    if (existingNode) {
+                        list_1.List.AddNode(nextNodeList, existingNode);
+                        if (existingNode.data.scope.dirty) {
+                            vNode.DestroyAll(existingNode.data.nodes);
+                            existingNode.data.nodes = Store_1.ObservableScope.Value(existingNode.data.scope);
+                        }
+                    }
+                    else {
+                        nodeListMap.delete(data);
+                        const childrenScope = Store_1.ObservableScope.Create(function () {
+                            const childNodes = injector_1.Injector.Scope(injector, children, data);
+                            const nodes = typeof childNodes === 'string' ? [vNode.Create({
+                                    type: 'text',
+                                    namespace: null,
+                                    props: {
+                                        nodeValue: childNodes
+                                    }
+                                })] : Array.isArray(childNodes) ? childNodes : [childNodes];
+                            return nodes;
+                        });
+                        list_1.List.Add(nextNodeList, {
+                            data,
+                            nodes: Store_1.ObservableScope.Value(childrenScope),
+                            scope: childrenScope
+                        });
+                    }
+                    nextNodeArray.push(...nextNodeList.tail.data.nodes);
+                }
+                for (let value of nodeListMap.values())
+                    DestroyNodeList(value);
+                list_1.List.Append(nodeList, nextNodeList);
+                return nextNodeArray;
+            }
+        }
     };
 }
 function DestroyNodeList(nodeList) {
@@ -182,77 +239,11 @@ function DestroyNodeList(nodeList) {
         vNode.DestroyAll(node.data.nodes);
         Store_1.ObservableScope.Destroy(node.data.scope);
     }
-}
-function DynamicChildren(vnode, children, data) {
-    const dataScope = Store_1.ObservableScope.Create(data);
-    vnode.scopes.push(dataScope);
-    const nodeList = list_1.List.Create();
-    const childrenScope = Store_1.ObservableScope.Create(WrapDynamicChildren(dataScope, nodeList, vnode.injector, children));
-    vnode.scopes.push(childrenScope);
-    Store_1.ObservableScope.OnDestroyed(dataScope, function () {
-        DestroyNodeList(nodeList);
-    });
-    Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function () {
-        if (vnode.destroyed)
-            return;
-        vnode.children = Store_1.ObservableScope.Peek(childrenScope);
-        UpdateChildren(vnode);
-    }));
-    vnode.children = Store_1.ObservableScope.Value(childrenScope);
+    list_1.List.Clear(nodeList);
 }
 function GetData(data) {
     return data.data;
 }
-function WrapDynamicChildren(dataScope, nodeList, injector, children) {
-    return function () {
-        const nextData = Store_1.ObservableScope.Value(dataScope);
-        const nodeMap = list_1.List.ToNodeMap(nodeList, GetData);
-        const nextNodeList = list_1.List.Create();
-        const nextNodeArray = [];
-        for (let x = 0; x < nextData.length; x++) {
-            const data = nextData[x];
-            const existingNodeArray = nodeMap.get(data);
-            let existingNode = null;
-            for (let x = 0; existingNodeArray &&
-                x < existingNodeArray.length &&
-                existingNode === null; x++) {
-                existingNode = existingNodeArray[x];
-                existingNodeArray[x] = null;
-            }
-            if (existingNode !== null) {
-                list_1.List.RemoveNode(nodeList, existingNode);
-                list_1.List.AddNode(nextNodeList, existingNode);
-                if (existingNode.data.scope.dirty) {
-                    vNode.DestroyAll(existingNode.data.nodes);
-                    existingNode.data.nodes = Store_1.ObservableScope.Value(existingNode.data.scope);
-                }
-            }
-            else {
-                const childrenScope = Store_1.ObservableScope.Create(function () {
-                    const childNodes = injector_1.Injector.Scope(injector, children, data);
-                    const nodes = typeof childNodes === 'string' ? [vNode.Create({
-                            type: 'text',
-                            namespace: null,
-                            props: {
-                                nodeValue: childNodes
-                            }
-                        })] : Array.isArray(childNodes) ? childNodes : [childNodes];
-                    return nodes;
-                });
-                list_1.List.Add(nextNodeList, {
-                    data,
-                    nodes: Store_1.ObservableScope.Value(childrenScope),
-                    scope: childrenScope,
-                });
-            }
-            nextNodeArray.push(...nextNodeList.tail.data.nodes);
-        }
-        DestroyNodeList(nodeList);
-        list_1.List.Clear(nodeList);
-        list_1.List.Append(nodeList, nextNodeList);
-        return nextNodeArray;
-    };
-}
 function UpdateChildren(vnode, init = false, skipInit = false) {
     if (!vnode.children)
         return;
@@ -310,13 +301,13 @@ function ScheduledAssignment(assign) {
 }
 function CreateScheduledCallback(callback) {
     let scheduled = false;
-    return function () {
+    return function (...args) {
         if (scheduled)
             return;
         scheduled = true;
         nodeConfig_1.NodeConfig.scheduleUpdate(function () {
             scheduled = false;
-            callback();
+            callback(...args);
         });
     };
 }

package/Node/vNode.types.d.ts

@@ -14,6 +14,7 @@ export type vNodeEvents<E extends {
 };
 export type vNodeChildrenFunction<T> = ((data: T) => vNode | vNode[]) | ((data: T) => string);
 export type vNode = {
+    type: string;
     definition: vNodeDefinition<any, any, any>;
     injector: Injector;
     node: Node | null;

package/Store/Tree/observableScope.js

@@ -232,7 +232,6 @@ function UpdateEmitters(scope, right) {
 function DestroyScope(scope) {
     if (!scope)
         return;
-    const emitters = scope.emitters;
     scope.emitters = null;
     scope.emitter = null;
     scope.getFunction = null;

package/Utils/list.d.ts

@@ -26,4 +26,5 @@ export declare namespace List {
     }): void;
     function Append<T>(appendTo: IList<T>, append: IList<T>): void;
     function ToNodeMap<T>(list: IList<T>, keyCallback: (data: T) => unknown): Map<any, INode<T>[]>;
+    function ToListMap<T>(list: IList<T>, keyCallback: (data: T) => unknown): Map<any, IList<T>>;
 }

package/Utils/list.js

@@ -209,4 +209,18 @@ var List;
         return map;
     }
     List.ToNodeMap = ToNodeMap;
+    function ToListMap(list, keyCallback) {
+        const map = new Map();
+        let node = list.head;
+        while (node !== null) {
+            const key = keyCallback(node.data);
+            const mapList = map.get(key) ?? List.Create();
+            List.RemoveNode(list, node);
+            List.AddNode(mapList, node);
+            map.set(key, mapList);
+            node = list.head;
+        }
+        return map;
+    }
+    List.ToListMap = ToListMap;
 })(List || (exports.List = List = {}));

package/package.json

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