j-templates 7.0.31 → 7.0.33

package/DOM/createPropertyAssignment.d.ts

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

package/DOM/createPropertyAssignment.js

@@ -52,6 +52,11 @@ function GetAssignmentFunction(path) {
     }
 }
 function CreatePropertyAssignment(target) {
+    if (target.nodeType === Node.TEXT_NODE) {
+        return function (next) {
+            AssignNodeValue(target, next.nodeValue);
+        };
+    }
     const last = [
         ["", null, null],
     ];

package/Node/vNode.js

@@ -11,8 +11,9 @@ var vNode;
     function Create(definition) {
         return {
             definition,
+            type: definition.type,
             injector: injector_1.Injector.Current() ?? new injector_1.Injector(),
-            node: null,
+            node: definition.node ?? null,
             children: null,
             destroyed: false,
             component: null,
@@ -69,7 +70,7 @@ var vNode;
 })(vNode || (exports.vNode = vNode = {}));
 function InitNode(vnode) {
     const { type, namespace, props, attrs, on, data, componentConstructor, children, childrenArray, } = vnode.definition;
-    const node = (vnode.node = nodeConfig_1.NodeConfig.createNode(type, namespace));
+    const node = (vnode.node = vnode.definition.node ?? nodeConfig_1.NodeConfig.createNode(type, namespace));
     vnode.definition = null;
     if (props) {
         const assignProperties = nodeConfig_1.NodeConfig.createPropertyAssignment(node);
@@ -133,48 +134,86 @@ 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);
     }
     UpdateChildren(vnode, true, !!childrenArray);
 }
-function StaticChildren(vnode, children) {
-    const childrenScope = Store_1.ObservableScope.Create(WrapStaticChildren(vnode.injector, children));
+function Children(vnode, children, data) {
+    const childrenScope = CreateChildrenScope(vnode, children, data);
     vnode.scopes.push(childrenScope);
-    const child = Store_1.ObservableScope.Peek(childrenScope);
-    switch (typeof child) {
-        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];
-            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]);
-            break;
-        }
-    }
+    Store_1.ObservableScope.Watch(childrenScope, CreateScheduledCallback(function (scope) {
+        if (vnode.destroyed)
+            return;
+        AssignChildren(vnode, scope);
+        UpdateChildren(vnode);
+    }));
+    AssignChildren(vnode, childrenScope);
 }
-function WrapStaticChildren(injector, children) {
+function CreateChildrenScope(vnode, children, data) {
+    if (data === undefined)
+        return Store_1.ObservableScope.Create(WrapStaticChildren(vnode, children));
+    const nodeList = list_1.List.Create();
+    const scope = Store_1.ObservableScope.Create(WrapChildren(vnode.injector, children, ToArray(data), nodeList));
+    Store_1.ObservableScope.OnDestroyed(scope, function () {
+        DestroyNodeList(nodeList);
+    });
+    return scope;
+}
+function WrapStaticChildren(vnode, children) {
+    return function () {
+        vnode.children && vNode.DestroyAll(vnode.children);
+        return injector_1.Injector.Scope(vnode.injector, children, undefined);
+    };
+}
+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 [];
+            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,76 +221,30 @@ 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);
+function AssignChildren(vnode, childrenScope) {
+    const children = Store_1.ObservableScope.Peek(childrenScope);
+    switch (typeof children) {
+        case 'string': {
+            vnode.children = [vNode.Create({
+                    type: 'text',
+                    namespace: null,
+                    node: vnode.children?.[0]?.type === 'text' && vnode.children[0].node || undefined,
+                    props: {
+                        nodeValue: children
+                    }
+                })];
+            break;
         }
-        DestroyNodeList(nodeList);
-        list_1.List.Clear(nodeList);
-        list_1.List.Append(nodeList, nextNodeList);
-        return nextNodeArray;
-    };
+        default: {
+            vnode.children = Array.isArray(children) ? children : [children];
+            break;
+        }
+    }
 }
 function UpdateChildren(vnode, init = false, skipInit = false) {
     if (!vnode.children)
@@ -261,7 +254,7 @@ function UpdateChildren(vnode, init = false, skipInit = false) {
         if (vnode.destroyed || children !== vnode.children)
             return;
         for (let x = 0; !skipInit && x < children.length; x++)
-            if (children[x].node === null) {
+            if (children[x].definition) {
                 const childNode = children[x];
                 (0, thread_1.Schedule)(function () {
                     if (vnode.destroyed || children !== vnode.children)
@@ -310,13 +303,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;
@@ -24,6 +25,7 @@ export type vNode = {
 };
 export type vNodeDefinition<P = HTMLElement, E = HTMLElementEventMap, T = never> = {
     type: string;
+    node?: Node;
     namespace: string | null;
     props?: FunctionOr<RecursivePartial<P>>;
     attrs?: FunctionOr<{

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.33",
   "description": "j-templates",
   "license": "MIT",
   "repository": "https://github.com/TypesInCode/jTemplates",