j-templates 5.0.47 → 5.0.48

package/jTemplates.js

@@ -88,7 +88,16 @@ exports.DOMNodeConfig = {
         var cEvent = new CustomEvent(event, data);
         target.dispatchEvent(cEvent);
     },
-    setProperties: utils_1.SetProperties
+    setProperties: utils_1.SetProperties,
+    getFirstChild(target) {
+        return target.firstChild;
+    },
+    getNextSibling(target) {
+        return target.nextSibling;
+    },
+    replaceChildren(target, children) {
+        target.replaceChildren(...children);
+    },
 };
 
 
@@ -660,13 +669,13 @@ function AddTemplate(node, init) {
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.ElementNode = void 0;
-const boundNode_1 = __webpack_require__(/*! ./boundNode */ "./src/Node/boundNode.ts");
-const nodeConfig_1 = __webpack_require__(/*! ./nodeConfig */ "./src/Node/nodeConfig.ts");
+const observableScope_1 = __webpack_require__(/*! ../Store/Tree/observableScope */ "./src/Store/Tree/observableScope.ts");
 const injector_1 = __webpack_require__(/*! ../Utils/injector */ "./src/Utils/injector.ts");
 const list_1 = __webpack_require__(/*! ../Utils/list */ "./src/Utils/list.ts");
 const thread_1 = __webpack_require__(/*! ../Utils/thread */ "./src/Utils/thread.ts");
+const boundNode_1 = __webpack_require__(/*! ./boundNode */ "./src/Node/boundNode.ts");
+const nodeConfig_1 = __webpack_require__(/*! ./nodeConfig */ "./src/Node/nodeConfig.ts");
 const nodeRef_1 = __webpack_require__(/*! ./nodeRef */ "./src/Node/nodeRef.ts");
-const observableScope_1 = __webpack_require__(/*! ../Store/Tree/observableScope */ "./src/Store/Tree/observableScope.ts");
 var ElementNode;
 (function (ElementNode) {
     function Create(type, namespace, nodeDef, children) {
@@ -726,75 +735,99 @@ function SetDefaultData(node) {
             (0, thread_1.Thread)(function () {
                 if (node.destroyed)
                     return;
-                DetachAndAddNodes(node, [], [nodes]);
+                const defaultNodeList = list_1.List.Create();
+                list_1.List.Add(defaultNodeList, {
+                    value: null,
+                    init: true,
+                    nodes
+                });
+                nodeRef_1.NodeRef.ReconcileChildren(node, defaultNodeList);
             });
         }
     });
 }
-function SetData(node, values, init = false) {
-    (0, thread_1.Synch)(function () {
-        const newNodesMap = new Map();
-        const newNodesArrays = new Array(values.length);
-        for (let x = 0; x < values.length; x++) {
-            const value = values[x];
-            let nodes;
-            if (node.nodesMap) {
-                let nodeArrayList = node.nodesMap.get(value);
-                nodes = nodeArrayList && list_1.List.Remove(nodeArrayList);
-            }
-            let newNodeArrayList = newNodesMap.get(value);
-            if (!newNodeArrayList) {
-                newNodeArrayList = list_1.List.Create();
-                newNodesMap.set(value, newNodeArrayList);
-            }
-            if (!nodes) {
-                nodes = injector_1.Injector.Scope(node.injector, CreateNodeArray, node.childrenFunc, value);
-                (0, thread_1.Schedule)(function () {
-                    if (node.destroyed || newNodesMap.size === 0)
-                        return;
-                    nodeRef_1.NodeRef.InitAll(nodes);
-                    list_1.List.Push(newNodeArrayList, nodes);
-                });
+function GetDataValue(data) {
+    return data.value;
+}
+function ReconcileNodeData(node, values) {
+    const nextNodeList = list_1.List.Create();
+    const initNodeList = list_1.List.Create();
+    const currentNodeList = node.nodeList;
+    const nodeMap = currentNodeList && list_1.List.ToNodeMap(currentNodeList, GetDataValue);
+    for (let x = 0; x < values.length; x++) {
+        let curNode;
+        if (nodeMap) {
+            const nodeArr = nodeMap.get(values[x]);
+            if (nodeArr) {
+                let y = nodeArr.length - 1;
+                for (; y >= 0 && !curNode; y--) {
+                    curNode = nodeArr[y];
+                    nodeArr[y] = null;
+                }
             }
-            else
-                list_1.List.Push(newNodeArrayList, nodes);
-            newNodesArrays[x] = nodes;
         }
-        var detachNodes = [];
-        if (node.nodesMap) {
-            for (var nodeArrayList of node.nodesMap.values())
-                nodeArrayList.size > 0 && detachNodes.push(DestroyNodeArrayList(nodeArrayList));
-            node.nodesMap.clear();
+        if (curNode) {
+            list_1.List.RemoveNode(currentNodeList, curNode);
+            list_1.List.AddNode(nextNodeList, curNode);
+            if (!curNode.data.init)
+                list_1.List.Add(initNodeList, curNode.data);
+        }
+        else {
+            curNode = list_1.List.Add(nextNodeList, {
+                value: values[x],
+                init: false,
+                nodes: injector_1.Injector.Scope(node.injector, CreateNodeArray, node.childrenFunc, values[x])
+            });
+            list_1.List.Add(initNodeList, curNode.data);
         }
-        node.nodesMap = newNodesMap;
+    }
+    let curNode = initNodeList.head;
+    while (curNode) {
+        const data = curNode.data;
+        (0, thread_1.Schedule)(function () {
+            if (node.destroyed || nextNodeList.size === 0)
+                return;
+            nodeRef_1.NodeRef.InitAll(data.nodes);
+            data.init = true;
+        });
+        curNode = curNode.next;
+    }
+    if (currentNodeList) {
+        let curDetach = currentNodeList.head;
+        while (curDetach) {
+            nodeRef_1.NodeRef.DestroyAll(curDetach.data.nodes);
+            for (let x = 0; x < curDetach.data.nodes.length; x++)
+                node.childNodes.delete(curDetach.data.nodes[x]);
+            curDetach = curDetach.next;
+        }
+        list_1.List.Clear(currentNodeList);
+    }
+    let curAttach = nextNodeList.head;
+    while (curAttach) {
+        for (let x = 0; x < curAttach.data.nodes.length; x++)
+            node.childNodes.add(curAttach.data.nodes[x]);
+        curAttach = curAttach.next;
+    }
+    node.nodeList = nextNodeList;
+}
+function SetData(node, values, init = false) {
+    (0, thread_1.Synch)(function () {
+        ReconcileNodeData(node, values);
+        const attachNodes = node.nodeList;
         (0, thread_1.Thread)(function () {
             if (node.destroyed)
                 return;
             if (init)
-                DetachAndAddNodes(node, detachNodes, newNodesMap.size > 0 && newNodesArrays);
+                nodeRef_1.NodeRef.ReconcileChildren(node, attachNodes);
             else
                 nodeConfig_1.NodeConfig.scheduleUpdate(function () {
-                    if (node.destroyed)
+                    if (node.destroyed || attachNodes.size < node.childNodes.size)
                         return;
-                    DetachAndAddNodes(node, detachNodes, newNodesMap.size > 0 && newNodesArrays);
+                    nodeRef_1.NodeRef.ReconcileChildren(node, attachNodes);
                 });
         });
     });
 }
-function DetachAndAddNodes(node, detachNodes, newNodes) {
-    for (var x = 0; x < detachNodes.length; x++)
-        list_1.List.ForEach(detachNodes[x], function (nodes) {
-            for (var x = 0; x < nodes.length; x++)
-                nodeRef_1.NodeRef.DetachChild(node, nodes[x]);
-        });
-    var previousNode = null;
-    for (var x = 0; newNodes && x < newNodes.length; x++) {
-        for (var y = 0; y < newNodes[x].length; y++) {
-            nodeRef_1.NodeRef.AddChildAfter(node, previousNode, newNodes[x][y]);
-            previousNode = newNodes[x][y];
-        }
-    }
-}
 function CreateNodeArray(childrenFunc, value) {
     var newNodes = childrenFunc(value);
     if (typeof newNodes === "string") {
@@ -810,10 +843,6 @@ function CreateNodeArray(childrenFunc, value) {
         return newNodes;
     return [newNodes];
 }
-function DestroyNodeArrayList(nodeArrayList) {
-    list_1.List.ForEach(nodeArrayList, nodeRef_1.NodeRef.DestroyAll);
-    return nodeArrayList;
-}
 
 
 /***/ }),
@@ -911,7 +940,7 @@ var NodeRef;
                     setAttributes: false,
                     setEvents: false,
                     childrenFunc: null,
-                    nodesMap: null,
+                    nodeList: null,
                     setData: false
                 };
             case NodeRefType.ComponentNode:
@@ -966,16 +995,41 @@ var NodeRef;
     }
     NodeRef.AddChild = AddChild;
     function AddChildAfter(node, currentChild, newChild) {
-        if (currentChild && !node.childNodes.has(currentChild))
+        if (currentChild && currentChild.parent !== node)
             throw "currentChild is not valid";
         newChild.parent = node;
         node.childNodes.add(newChild);
         nodeConfig_1.NodeConfig.addChildAfter(node.node, currentChild && currentChild.node, newChild.node);
     }
     NodeRef.AddChildAfter = AddChildAfter;
+    function ReconcileChildren(node, nextChildren) {
+        const rootNode = node.node;
+        if (nextChildren.size === 0) {
+            nodeConfig_1.NodeConfig.replaceChildren(rootNode, []);
+            return;
+        }
+        let priorNode;
+        let curDataNode = nextChildren?.head;
+        while (curDataNode) {
+            for (let x = 0; x < curDataNode.data.nodes.length; x++) {
+                const actualNode = priorNode ? nodeConfig_1.NodeConfig.getNextSibling(priorNode) : nodeConfig_1.NodeConfig.getFirstChild(rootNode);
+                const expectedNode = curDataNode.data.nodes[x].node;
+                if (actualNode !== expectedNode) {
+                    nodeConfig_1.NodeConfig.addChildBefore(rootNode, actualNode, expectedNode);
+                }
+                priorNode = expectedNode;
+            }
+            curDataNode = curDataNode.next;
+        }
+        let remainingSibling = priorNode && nodeConfig_1.NodeConfig.getNextSibling(priorNode);
+        while (remainingSibling) {
+            nodeConfig_1.NodeConfig.removeChild(rootNode, remainingSibling);
+            remainingSibling = nodeConfig_1.NodeConfig.getNextSibling(priorNode);
+        }
+    }
+    NodeRef.ReconcileChildren = ReconcileChildren;
     function DetachChild(node, child) {
-        if (node.childNodes.has(child)) {
-            node.childNodes.delete(child);
+        if (node.childNodes.delete(child)) {
             nodeConfig_1.NodeConfig.removeChild(node.node, child.node);
             child.parent = null;
         }
@@ -985,7 +1039,7 @@ var NodeRef;
         if (node.destroyed)
             return;
         node.destroyed = true;
-        node.childNodes.forEach(Destroy);
+        node.childNodes?.forEach(Destroy);
         for (let x = 0; x < node.destroyables.length; x++)
             node.destroyables[x]?.Destroy();
     }
@@ -2089,14 +2143,12 @@ class ObservableTree {
         if (!parentValue)
             throw new Error("Unable to write path: " + path + ". Falsey value found at: " + pathParts.slice(0, x).join("."));
         const prop = pathParts[x];
-        const exists = Object.hasOwn(parentValue, prop);
         const oldValue = parentValue[prop];
         const oldType = TypeOf(oldValue);
         parentValue[prop] = value;
-        if (oldType !== Type.Value)
-            return this.scopeCache.get(oldValue) ||
-                this.scopeCache.get(parentValue);
-        const leafScopes = exists && this.leafScopeCache.get(parentValue);
+        if (oldType !== Type.Value || Array.isArray(parentValue))
+            return this.scopeCache.get(parentValue) || this.scopeCache.get(oldValue);
+        const leafScopes = this.leafScopeCache.get(parentValue);
         return leafScopes && leafScopes[prop] || this.scopeCache.get(parentValue);
     }
     UpdatePathCache(path, value) {
@@ -2104,6 +2156,9 @@ class ObservableTree {
         if (type === Type.Value)
             return;
         this.pathCache.set(value, path);
+        this.proxyCache.delete(value);
+        this.scopeCache.delete(value);
+        this.leafScopeCache.delete(value);
         const keys = Object.keys(value);
         for (let x = 0; x < keys.length; x++)
             this.UpdatePathCache(`${path}.${keys[x]}`, value[keys[x]]);
@@ -2791,7 +2846,11 @@ var List;
     }
     List.Pop = Pop;
     function Add(list, data) {
-        var node = { previous: null, next: null, data: data };
+        const node = { previous: null, next: null, data: data };
+        return AddNode(list, node);
+    }
+    List.Add = Add;
+    function AddNode(list, node) {
         if (list.size === 0) {
             list.head = node;
             list.tail = node;
@@ -2805,7 +2864,7 @@ var List;
         }
         return node;
     }
-    List.Add = Add;
+    List.AddNode = AddNode;
     function AddBefore(list, node, data) {
         if (!node)
             return List.Add(list, data);
@@ -2853,6 +2912,25 @@ var List;
         return node.data;
     }
     List.Remove = Remove;
+    function RemoveNode(list, node) {
+        if (list.head === node) {
+            list.head = node.next;
+        }
+        else if (list.tail === node) {
+            list.tail = node.previous;
+        }
+        else {
+            const prev = node.previous;
+            const next = node.next;
+            prev.next = next;
+            next.previous = prev;
+        }
+        node.next = node.previous = null;
+        list.size--;
+        if (list.size > 0)
+            list.head.previous = list.tail.next = null;
+    }
+    List.RemoveNode = RemoveNode;
     function ForEach(list, callback) {
         var node = list.head;
         while (node) {
@@ -2861,6 +2939,21 @@ var List;
         }
     }
     List.ForEach = ForEach;
+    function ToNodeMap(list, keyCallback) {
+        const map = new Map();
+        let node = list.head;
+        while (node) {
+            const key = keyCallback(node.data);
+            const nodes = map.get(key) || [node];
+            if (nodes[0] !== node)
+                nodes.push(node);
+            else
+                map.set(key, nodes);
+            node = node.next;
+        }
+        return map;
+    }
+    List.ToNodeMap = ToNodeMap;
 })(List || (exports.List = List = {}));