native-document 1.0.110 → 1.0.112

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

@@ -887,12 +887,11 @@ var NativeComponents = (function (exports) {
         DOCUMENT_FRAGMENT: 11
     };
 
-    const VALID_TYPES = {
-        [COMMON_NODE_TYPES.ELEMENT]: true,
-        [COMMON_NODE_TYPES.TEXT]: true,
-        [COMMON_NODE_TYPES.DOCUMENT_FRAGMENT]: true,
-        [COMMON_NODE_TYPES.COMMENT]: true
-    };
+    const VALID_TYPES = [];
+    VALID_TYPES[COMMON_NODE_TYPES.ELEMENT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.TEXT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.DOCUMENT_FRAGMENT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.COMMENT] = true;
 
     const Validator = {
         isObservable(value) {
@@ -2906,7 +2905,15 @@ var NativeComponents = (function (exports) {
             if (attributes) {
                 AttributesWrapper(element, attributes);
             }
-        }
+        },
+        /**
+         *
+         * @param {HTMLElement} element
+         * @param {Object} attributes
+         */
+        processAttributesDirect: AttributesWrapper,
+        processClassAttribute: bindClassAttribute,
+        processStyleAttribute: bindStyleAttribute,
     };
 
     const EVENTS = [

package/dist/native-document.dev.js

@@ -656,12 +656,11 @@ var NativeDocument = (function (exports) {
         DOCUMENT_FRAGMENT: 11
     };
 
-    const VALID_TYPES = {
-        [COMMON_NODE_TYPES.ELEMENT]: true,
-        [COMMON_NODE_TYPES.TEXT]: true,
-        [COMMON_NODE_TYPES.DOCUMENT_FRAGMENT]: true,
-        [COMMON_NODE_TYPES.COMMENT]: true
-    };
+    const VALID_TYPES = [];
+    VALID_TYPES[COMMON_NODE_TYPES.ELEMENT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.TEXT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.DOCUMENT_FRAGMENT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.COMMENT] = true;
 
     const Validator = {
         isObservable(value) {
@@ -2453,7 +2452,9 @@ var NativeDocument = (function (exports) {
      */
     function AttributesWrapper(element, attributes) {
 
-        Validator.validateAttributes(attributes);
+        {
+            Validator.validateAttributes(attributes);
+        }
 
         for(const originalAttributeName in attributes) {
             const attributeName = originalAttributeName.toLowerCase();
@@ -2764,7 +2765,15 @@ var NativeDocument = (function (exports) {
             if (attributes) {
                 AttributesWrapper(element, attributes);
             }
-        }
+        },
+        /**
+         *
+         * @param {HTMLElement} element
+         * @param {Object} attributes
+         */
+        processAttributesDirect: AttributesWrapper,
+        processClassAttribute: bindClassAttribute,
+        processStyleAttribute: bindStyleAttribute,
     };
 
     const EVENTS = [
@@ -3210,46 +3219,83 @@ var NativeDocument = (function (exports) {
 
     const cloneBindingsDataCache = new WeakMap();
 
+    const pathProcess = (target, path, data) => {
+        if(path.HYDRATE_TEXT) {
+            const value = path.value;
+            ElementCreator.bindTextNode(target, path.isString ? data[0][value] : value.apply(null, data));
+            return;
+        }
+        if(path.ATTACH_METHOD) {
+            const bindingData = path.bindingData;
+            for(let i = 0, length = bindingData._attachLength; i < length; i++) {
+                const method = bindingData.attach[i];
+                target.nd[method.methodName](function() {
+                    method.fn.call(this, ...data, ...arguments);
+                });
+            }
+        }
+        if(path.HYDRATE_ATTRIBUTES) {
+            path.hydrator(target, path.bindingData, data);
+        }
+    };
+
+    const buildAttributesCache = (bindDingData) => {
+        const cache = { };
+        if(bindDingData.attributes) cache.attributes = {};
+        if(bindDingData.classes)    cache.class = {};
+        if(bindDingData.styles)     cache.style = {};
+        bindDingData._cache = cache;
+    };
+
+    const prepareBindingMetadata = (bindDingData) => {
+        const attributes = [];
+        const classAndStyles = [];
 
-    const bindAttributes = (node, bindDingData, data) => {
-        let attributes = null;
         if(bindDingData.attributes) {
-            attributes = {};
             for (const attr in bindDingData.attributes) {
-                attributes[attr] = bindDingData.attributes[attr].apply(null, data);
+                attributes.push({
+                    name: attr,
+                    value: bindDingData.attributes[attr]
+                });
             }
         }
 
         if(bindDingData.classes) {
-            attributes = attributes || {};
-            attributes.class = {};
             for (const className in bindDingData.classes) {
-                attributes.class[className] = bindDingData.classes[className].apply(null, data);
+                bindDingData._hasClassAttribute = true;
+                classAndStyles.push({
+                    name: 'class',
+                    key: className,
+                    value: bindDingData.classes[className]
+                });
             }
         }
 
         if(bindDingData.styles) {
-            attributes = attributes || {};
-            attributes.style = {};
             for (const property in bindDingData.styles) {
-                attributes.style[property] = bindDingData.styles[property].apply(null, data);
+                bindDingData._hasStyleAttribute = true;
+                classAndStyles.push({
+                    name: 'style',
+                    key: property,
+                    value: bindDingData.styles[property]
+                });
             }
         }
 
-        if(attributes) {
-            ElementCreator.processAttributes(node, attributes);
-            return true;
-        }
-
-        return null;
+        bindDingData._flatAttributes = attributes;
+        bindDingData._flatAttributesLength = attributes.length;
+        bindDingData._flatDynamique = classAndStyles;
+        bindDingData._flatDynamiqueLength = classAndStyles.length;
+        bindDingData._attachLength = bindDingData.attach.length;
     };
 
+
     const $hydrateFn = function(hydrateFunction, targetType, element, property) {
         if(!cloneBindingsDataCache.has(element)) {
-            // { classes, styles, attributes, value, attach }
             cloneBindingsDataCache.set(element, { attach: [] });
         }
         const hydrationState = cloneBindingsDataCache.get(element);
+
         if(targetType === 'value') {
             hydrationState.value = hydrateFunction;
             return;
@@ -3264,87 +3310,191 @@ var NativeDocument = (function (exports) {
     };
 
     const bindAttachMethods = (node, bindDingData, data) => {
-        for(let i = 0, length = bindDingData.attach.length; i < length; i++) {
-            const { methodName, fn } = bindDingData.attach[i];
-            node.nd[methodName](function(...args) {
-                fn.apply(this, [...args, ...data]);
+        for(let i = 0, length = bindDingData._attachLength; i < length; i++) {
+            const method = bindDingData.attach[i];
+            node.nd[method.methodName](function() {
+                method.fn.call(this, ...data, ...arguments);
             });
         }
     };
 
+    const optimizeBindingData = (bindDingData) => {
+        buildAttributesCache(bindDingData);
+        prepareBindingMetadata(bindDingData);
+    };
 
-    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);
 
+    const $applyBindingParents = [];
+    const hydrateClonedNode = (root, data, paths, pathSize) => {
+        const rootPath = paths[pathSize];
+        $applyBindingParents[rootPath.id] = root;
+        pathProcess(root, rootPath, data);
 
-        for(let i = 0, length = paths.length - 1; i < length; i++) {
-            const path = paths[i];
-            const target = parents[path.parentId].childNodes[path.index];
+        let target = null, path = null;
+        for(let i = 0; i < pathSize; i++) {
+            path = paths[i];
+            target = $applyBindingParents[path.parentId].childNodes[path.index];
+            $applyBindingParents[path.id] = target;
 
-            parents[path.id] = target;
-            const pathFn = path.fn;
-            pathFn(data, target, root);
+            if(path.HYDRATE_TEXT) {
+                const value = path.value;
+                ElementCreator.bindTextNode(target, path.isString ? data[0][value] : value.apply(null, data));
+                continue;
+            }
+            if(path.ATTACH_METHOD) {
+                const bindingData = path.bindingData;
+                for(let i = 0, length = bindingData._attachLength; i < length; i++) {
+                    const method = bindingData.attach[i];
+                    target.nd[method.methodName](function() {
+                        method.fn.call(this, ...data, ...arguments);
+                    });
+                }
+            }
+            if(path.HYDRATE_ATTRIBUTES) {
+                path.hydrator(target, path.bindingData, data);
+            }
+        }
+
+        for (let i = 0; i <= pathSize; i++) {
+            $applyBindingParents[i] = null;
         }
-        parents.length = 0;
     };
 
-    const noUpdate = () => {};
+    const hydrateFull = (node, bindDingData, data) => {
+        const cacheAttributes = bindDingData._cache;
+
+        for(let i = 0, length = bindDingData._flatAttributesLength; i < length; i++) {
+            const attr = bindDingData._flatAttributes[i];
+            cacheAttributes[attr.name] = attr.value.apply(null, data);
+        }
+
+        for(let i = 0, length = bindDingData._flatDynamiqueLength; i < length; i++) {
+            const dyn = bindDingData._flatDynamique[i];
+            cacheAttributes[dyn.name][dyn.key] = dyn.value.apply(null, data);
+        }
+
+        ElementCreator.processAttributesDirect(node, cacheAttributes);
+        return true;
+    };
+
+    const hydrateDynamic = (node, bindDingData, data) => {
+        const cacheAttributes = bindDingData._cache;
+
+        for(let i = 0, length = bindDingData._flatDynamiqueLength; i < length; i++) {
+            const dyn = bindDingData._flatDynamique[i];
+            cacheAttributes[dyn.name][dyn.key] = dyn.value.apply(null, data);
+        }
+
+        ElementCreator.processClassAttribute(node, cacheAttributes.class);
+        ElementCreator.processStyleAttribute(node, cacheAttributes.style);
+        return true;
+    };
+
+    const hydrateClassAttribute = (node, bindDingData, data) => {
+        const classAttributes = bindDingData._cache.class;
+
+        for(let i = 0, length = bindDingData._flatDynamiqueLength; i < length; i++) {
+            const dyn = bindDingData._flatDynamique[i];
+            classAttributes[dyn.key] = dyn.value.apply(null, data);
+        }
+
+        ElementCreator.processClassAttribute(node, classAttributes);
+        return true;
+    };
+
+    const hydrateStyleAttribute = (node, bindDingData, data) => {
+        const styleAttributes = bindDingData._cache;
+
+        for(let i = 0, length = bindDingData._flatDynamiqueLength; i < length; i++) {
+            const dyn = bindDingData._flatDynamique[i];
+            styleAttributes[dyn.key] = dyn.value.apply(null, data);
+        }
+
+        ElementCreator.processStyleAttribute(node, styleAttributes);
+        return true;
+    };
+
+    const hydrateAttributes = (node, bindDingData, data) => {
+        const cacheAttributes = bindDingData._cache;
+
+        for(let i = 0, length = bindDingData._flatAttributesLength; i < length; i++) {
+            const attr = bindDingData._flatAttributes[i];
+            cacheAttributes[attr.name] = attr.value.apply(null, data);
+        }
+
+        ElementCreator.processAttributesDirect(node, cacheAttributes);
+        return true;
+    };
+
+    const getHydrator = (bindDingData) => {
+        if(!bindDingData._cache) {
+            return noUpdate;
+        }
+        if(bindDingData._flatAttributesLength && bindDingData._flatDynamiqueLength) {
+            return hydrateFull;
+        }
+        if(bindDingData._flatAttributesLength) {
+            return hydrateAttributes;
+        }
+        if(bindDingData._hasClassAttribute && bindDingData._hasStyleAttribute) {
+            return hydrateDynamic;
+        }
+        if(bindDingData._hasClassAttribute) {
+            return hydrateClassAttribute;
+        }
+        return hydrateStyleAttribute;
+    };
+
     function TemplateCloner($fn) {
         let $node = null;
         let $hasBindingData = false;
 
+        let $bindingTreePathSize = 0;
         const $bindingTreePath = [
             {
                 id: 0,
-                parentId: null,
-                fn: noUpdate,
+                parentId: null
             }
         ];
 
         let pathCounter = 0;
         const clone = (node, data, currentPath) => {
             const bindDingData = cloneBindingsDataCache.get(node);
+            if(bindDingData) {
+                optimizeBindingData(bindDingData);
+            }
             if(node.nodeType === 3) {
                 if(bindDingData && bindDingData.value) {
-                    currentPath.fn = bindDingData.value;
+                    const value = bindDingData.value;
                     const textNode = node.cloneNode();
-                    if(typeof bindDingData.value === 'string') {
-                        ElementCreator.bindTextNode(textNode, data[0][bindDingData.value]);
-                        return textNode;
-                    }
-                    bindDingData.value(data, textNode);
+                    currentPath.value = value;
+                    currentPath.HYDRATE_TEXT = true;
+                    currentPath.operation = true;
+                    currentPath.isString = (typeof value === 'string');
+                    ElementCreator.bindTextNode(textNode, (currentPath.isString ? data[0][value] : value.apply(null, data)));
                     return textNode;
                 }
                 return node.cloneNode(true);
             }
             const nodeCloned = node.cloneNode();
             if(bindDingData) {
-                bindAttributes(nodeCloned, bindDingData, data);
+                const hydrator = getHydrator(bindDingData);
+                hydrator(nodeCloned, bindDingData, data);
                 bindAttachMethods(nodeCloned, 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);
-                    };
+                currentPath.bindingData = bindDingData;
+                currentPath.hydrator = hydrator;
+
+                if(hasAttributes) {
+                    currentPath.HYDRATE_ATTRIBUTES = true;
+                    currentPath.operation = true;
                 }
-                else if(hasAttachMethods) {
-                    currentPath.fn = (data, targetNode) => {
-                        bindAttachMethods(targetNode, bindDingData, data);
-                    };
+                if(hasAttachMethods) {
+                    currentPath.ATTACH_METHOD = true;
+                    currentPath.operation = true;
                 }
             }
             const childNodes = node.childNodes;
@@ -3352,10 +3502,10 @@ var NativeDocument = (function (exports) {
 
             for(let i = 0, length = childNodes.length; i < length; i++) {
                 const childNode = childNodes[i];
-                const path = { parentId, id: ++pathCounter,  index: i, fn: noUpdate };
+                const path = { parentId, id: ++pathCounter,  index: i };
                 const childNodeCloned = clone(childNode, data, path);
-                if(path.hasChildren || path.fn) {
-                    $bindingTreePath.unshift(path);
+                if(path.hasChildren || path.operation) {
+                    $bindingTreePath.push(path);
                     currentPath.hasChildren = true;
                 }
                 nodeCloned.appendChild(childNodeCloned);
@@ -3366,18 +3516,22 @@ var NativeDocument = (function (exports) {
         const cloneWithBindingPaths = (data) => {
             let root = $node.cloneNode(true);
 
-            applyBindingTreePath(root, data, $bindingTreePath);
+            hydrateClonedNode(root, data, $bindingTreePath, $bindingTreePathSize);
             return root;
         };
 
         this.clone = (data) => {
-            $node = $fn(this);
+            const binder = createTemplateCloner(this);
+            $node = $fn(binder);
             if(!$hasBindingData) {
                 this.clone = () => $node.cloneNode(true);
                 return $node.cloneNode(true);
             }
 
             const firstClone = clone($node, data, $bindingTreePath[0]);
+            $bindingTreePath.reverse();
+            $bindingTreePathSize = $bindingTreePath.length - 1;
+
             this.clone = cloneWithBindingPaths;
             return firstClone;
         };
@@ -3400,14 +3554,7 @@ var NativeDocument = (function (exports) {
             return this.value(propertyName);
         };
         this.value = (callbackOrProperty) => {
-            if(typeof callbackOrProperty !== 'function') {
-                return createBinding((data, textNode) => {
-                    ElementCreator.bindTextNode(textNode, data[0][callbackOrProperty]);
-                }, 'value');
-            }
-            return createBinding((data, textNode) => {
-                ElementCreator.bindTextNode(textNode, callbackOrProperty(...data));
-            }, 'value');
+            return createBinding(callbackOrProperty, 'value');
         };
         this.text = this.value;
         this.attr = (fn) => {
@@ -3416,26 +3563,40 @@ var NativeDocument = (function (exports) {
         this.attach = (fn) => {
             return createBinding(fn, 'attach');
         };
+        this.callback = this.attach;
+    }
 
+
+    function createTemplateCloner($binder) {
+        return new Proxy($binder, {
+            get(target, prop) {
+                if(prop in target) {
+                    return target[prop];
+                }
+                if (typeof prop === 'symbol') return target[prop];
+                return target.value(prop);
+            }
+        });
     }
 
     function useCache(fn) {
         let $cache = null;
 
-        let wrapper = function(args) {
+        let wrapper = (args) => {
             $cache = new TemplateCloner(fn);
-            wrapper = function(args) {
+
+            wrapper = (args) => {
                 return $cache.clone(args);
             };
             return $cache.clone(args);
         };
 
         if(fn.length < 2) {
-            return function(...args) {
+            return (...args) => {
                 return wrapper(args);
             };
         }
-        return function(_, __, ...args) {
+        return (_, __, ...args) => {
             return wrapper([_, __, ...args]);
         };
     }