native-document 1.0.108 → 1.0.109

package/dist/native-document.components.min.js

@@ -3058,12 +3058,10 @@ var NativeComponents = (function (exports) {
       "ContextMenu"
     ];
 
-    const $sharedNdElement = new NDElement(null);
     const property = {
         configurable: true,
         get() {
-            $sharedNdElement.$element = this;
-            return $sharedNdElement;
+            return new NDElement(this);
         }
     };
 

package/dist/native-document.dev.js

@@ -2916,12 +2916,10 @@ var NativeDocument = (function (exports) {
       "ContextMenu"
     ];
 
-    const $sharedNdElement = new NDElement(null);
     const property = {
         configurable: true,
         get() {
-            $sharedNdElement.$element = this;
-            return $sharedNdElement;
+            return new NDElement(this);
         }
     };
 
@@ -3249,56 +3247,66 @@ var NativeDocument = (function (exports) {
     const $hydrateFn = function(hydrateFunction, targetType, element, property) {
         if(!cloneBindingsDataCache.has(element)) {
             // { classes, styles, attributes, value, attach }
-            cloneBindingsDataCache.set(element, {});
+            cloneBindingsDataCache.set(element, { attach: [] });
         }
         const hydrationState = cloneBindingsDataCache.get(element);
         if(targetType === 'value') {
             hydrationState.value = hydrateFunction;
             return;
         }
+        if(targetType === 'attach') {
+            hydrationState.attach = hydrationState.attach || [];
+            hydrationState.attach.push({ methodName: property, fn: hydrateFunction});
+            return;
+        }
         hydrationState[targetType] = hydrationState[targetType] || {};
         hydrationState[targetType][property] = hydrateFunction;
     };
 
     const bindAttachMethods = (node, bindDingData, data) => {
-        if(!bindDingData.attach) {
-            return null;
-        }
-        for(const methodName in bindDingData.attach) {
+        for(let i = 0, length = bindDingData.attach.length; i < length; i++) {
+            const { methodName, fn } = bindDingData.attach[i];
             node.nd[methodName](function(...args) {
-                bindDingData.attach[methodName].apply(this, [...args, ...data]);
+                fn.apply(this, [...args, ...data]);
             });
         }
     };
 
 
-    const applyBindingTreePath = (root, target, data, path) => {
-        if(path.fn) {
-            if(typeof path.fn === 'string') {
-                ElementCreator.bindTextNode(target, data[0][path.fn]);
-            }
-            else {
-                path.fn(data, target, root);
-            }
-        }
-        if(path.children) {
-            for(let i = 0, length = path.children.length; i < length; i++) {
-                const currentPath = path.children[i];
-                const pathTargetNode = target.childNodes[currentPath.index];
-                applyBindingTreePath(root, pathTargetNode, data, currentPath);
-            }
+    const applyBindingTreePath = (root, data, paths) => {
+        const rootPath = paths.at(-1);
+        const parents = [];
+        parents[rootPath.id] = root;
+        data[0];
+        const rootPathFn = rootPath.fn;
+        rootPathFn(data, root, root);
+
+
+        for(let i = 0, length = paths.length - 1; i < length; i++) {
+            const path = paths[i];
+            const target = parents[path.parentId].childNodes[path.index];
+
+            parents[path.id] = target;
+            const pathFn = path.fn;
+            pathFn(data, target, root);
         }
+        parents.length = 0;
     };
 
+    const noUpdate = () => {};
     function TemplateCloner($fn) {
         let $node = null;
         let $hasBindingData = false;
 
-        const $bindingTreePath = {
-            fn: null,
-            children: [],
-        };
+        const $bindingTreePath = [
+            {
+                id: 0,
+                parentId: null,
+                fn: noUpdate,
+            }
+        ];
 
+        let pathCounter = 0;
         const clone = (node, data, currentPath) => {
             const bindDingData = cloneBindingsDataCache.get(node);
             if(node.nodeType === 3) {
@@ -3318,33 +3326,47 @@ var NativeDocument = (function (exports) {
             if(bindDingData) {
                 bindAttributes(nodeCloned, bindDingData, data);
                 bindAttachMethods(nodeCloned, bindDingData, data);
-                currentPath.fn = (data, targetNode) => {
-                    bindAttributes(targetNode, bindDingData, data);
-                    bindAttachMethods(targetNode, bindDingData, data);
-                };
+
+                const hasAttributes = bindDingData.classes || bindDingData.styles || bindDingData.attributes;
+                const hasAttachMethods = bindDingData.attach.length;
+
+                if(hasAttributes && hasAttachMethods) {
+                    currentPath.fn = (data, targetNode) => {
+                        bindAttributes(targetNode, bindDingData, data);
+                        bindAttachMethods(targetNode, bindDingData, data);
+                    };
+                }
+                else if(hasAttributes) {
+                    currentPath.fn = (data, targetNode) => {
+                        bindAttributes(targetNode, bindDingData, data);
+                    };
+                }
+                else if(hasAttachMethods) {
+                    currentPath.fn = (data, targetNode) => {
+                        bindAttachMethods(targetNode, bindDingData, data);
+                    };
+                }
             }
             const childNodes = node.childNodes;
-            const bindingPathChildren = [];
+            const parentId = currentPath.id;
+
             for(let i = 0, length = childNodes.length; i < length; i++) {
                 const childNode = childNodes[i];
-                const path = { index: i, fn: null };
+                const path = { parentId, id: ++pathCounter,  index: i, fn: noUpdate };
                 const childNodeCloned = clone(childNode, data, path);
-                if(path.children || path.fn) {
-                    bindingPathChildren.push(path);
+                if(path.hasChildren || path.fn) {
+                    $bindingTreePath.unshift(path);
+                    currentPath.hasChildren = true;
                 }
                 nodeCloned.appendChild(childNodeCloned);
             }
-            if(bindingPathChildren.length) {
-                currentPath.children = currentPath.children || [];
-                currentPath.children = bindingPathChildren;
-            }
             return nodeCloned;
         };
 
         const cloneWithBindingPaths = (data) => {
             let root = $node.cloneNode(true);
 
-            applyBindingTreePath(root, root, data, $bindingTreePath);
+            applyBindingTreePath(root, data, $bindingTreePath);
             return root;
         };
 
@@ -3355,7 +3377,7 @@ var NativeDocument = (function (exports) {
                 return $node.cloneNode(true);
             }
 
-            const firstClone = clone($node, data, $bindingTreePath);
+            const firstClone = clone($node, data, $bindingTreePath[0]);
             this.clone = cloneWithBindingPaths;
             return firstClone;
         };
@@ -3379,7 +3401,9 @@ var NativeDocument = (function (exports) {
         };
         this.value = (callbackOrProperty) => {
             if(typeof callbackOrProperty !== 'function') {
-                return createBinding(callbackOrProperty, 'value');
+                return createBinding((data, textNode) => {
+                    ElementCreator.bindTextNode(textNode, data[0][callbackOrProperty]);
+                }, 'value');
             }
             return createBinding((data, textNode) => {
                 ElementCreator.bindTextNode(textNode, callbackOrProperty(...data));
@@ -3398,10 +3422,11 @@ var NativeDocument = (function (exports) {
     function useCache(fn) {
         let $cache = null;
 
-        const wrapper = function(args) {
-            if(!$cache) {
-                $cache = new TemplateCloner(fn);
-            }
+        let wrapper = function(args) {
+            $cache = new TemplateCloner(fn);
+            wrapper = function(args) {
+                return $cache.clone(args);
+            };
             return $cache.clone(args);
         };