native-document 1.0.81 → 1.0.83

package/src/core/utils/plugins-manager.js

@@ -1,77 +1,81 @@
 import DebugManager from "./debug-manager";
 
-const PluginsManager = (function() {
+let PluginsManager = null;
 
-    const $plugins = new Map();
-    const $pluginByEvents = new Map();
+if(process.env.NODE_ENV === 'development') {
+    PluginsManager = (function() {
 
-    return {
-        list() {
-            return $pluginByEvents;
-        },
-        add(plugin, name){
-            if (!plugin || typeof plugin !== 'object') {
-                throw new Error(`Plugin ${name} must be an object`);
-            }
-            name = name || plugin.name;
-            if (!name || typeof name !== 'string') {
-                throw new Error(`Please, provide a valid plugin name`);
-            }
-            if($plugins.has(name)) {
-                return;
-            }
+        const $plugins = new Map();
+        const $pluginByEvents = new Map();
 
-            plugin.$name = name;
-            $plugins.set(name ,plugin);
-            if(typeof plugin?.init === 'function') {
-                plugin.init();
-            }
-            for(const methodName in plugin) {
-                if(/^on[A-Z]/.test(methodName)) {
-                    const eventName = methodName.replace(/^on/, '');
-                    if(!$pluginByEvents.has(eventName)) {
-                        $pluginByEvents.set(eventName, new Set());
+        return {
+            list() {
+                return $pluginByEvents;
+            },
+            add(plugin, name){
+                if (!plugin || typeof plugin !== 'object') {
+                    throw new Error(`Plugin ${name} must be an object`);
+                }
+                name = name || plugin.name;
+                if (!name || typeof name !== 'string') {
+                    throw new Error(`Please, provide a valid plugin name`);
+                }
+                if($plugins.has(name)) {
+                    return;
+                }
+
+                plugin.$name = name;
+                $plugins.set(name ,plugin);
+                if(typeof plugin?.init === 'function') {
+                    plugin.init();
+                }
+                for(const methodName in plugin) {
+                    if(/^on[A-Z]/.test(methodName)) {
+                        const eventName = methodName.replace(/^on/, '');
+                        if(!$pluginByEvents.has(eventName)) {
+                            $pluginByEvents.set(eventName, new Set());
+                        }
+                        $pluginByEvents.get(eventName).add(plugin);
                     }
-                    $pluginByEvents.get(eventName).add(plugin);
                 }
-            }
-        },
-        remove(pluginName){
-            if(!$plugins.has(pluginName)) {
-                return;
-            }
-            const plugin = $plugins.get(pluginName);
-            if(typeof plugin.cleanup === 'function') {
-                plugin.cleanup();
-            }
-            for(const [name, sets] of $pluginByEvents.entries() ) {
-                if(sets.has(plugin)) {
-                    sets.delete(plugin);
+            },
+            remove(pluginName){
+                if(!$plugins.has(pluginName)) {
+                    return;
                 }
-                if(sets.size === 0) {
-                    $pluginByEvents.delete(name);
+                const plugin = $plugins.get(pluginName);
+                if(typeof plugin.cleanup === 'function') {
+                    plugin.cleanup();
                 }
-            }
-            $plugins.delete(pluginName);
-        },
-        emit(eventName, ...data) {
-            if(!$pluginByEvents.has(eventName)) {
-                return;
-            }
-            const plugins = $pluginByEvents.get(eventName);
+                for(const [name, sets] of $pluginByEvents.entries() ) {
+                    if(sets.has(plugin)) {
+                        sets.delete(plugin);
+                    }
+                    if(sets.size === 0) {
+                        $pluginByEvents.delete(name);
+                    }
+                }
+                $plugins.delete(pluginName);
+            },
+            emit(eventName, ...data) {
+                if(!$pluginByEvents.has(eventName)) {
+                    return;
+                }
+                const plugins = $pluginByEvents.get(eventName);
 
-            for(const plugin of plugins) {
-                const callback = plugin['on'+eventName];
-                if(typeof callback === 'function') {
-                    try{
-                        callback.call(plugin, ...data);
-                    } catch (error) {
-                        DebugManager.error('Plugin Manager', `Error in plugin ${plugin.$name} for event ${eventName}`, error);
+                for(const plugin of plugins) {
+                    const callback = plugin['on'+eventName];
+                    if(typeof callback === 'function') {
+                        try{
+                            callback.call(plugin, ...data);
+                        } catch (error) {
+                            DebugManager.error('Plugin Manager', `Error in plugin ${plugin.$name} for event ${eventName}`, error);
+                        }
                     }
                 }
             }
-        }
-    };
-}());
+        };
+    }());
+}
 
 export default PluginsManager;

package/src/core/utils/validator.js

@@ -15,10 +15,10 @@ const COMMON_NODE_TYPES = {
 
 const Validator = {
     isObservable(value) {
-        return  value?.__$isObservable || value instanceof ObservableItem || value instanceof ObservableChecker;
+        return  value?.__$isObservable;
     },
     isTemplateBinding(value) {
-        return  value?.__$isTemplateBinding || value instanceof TemplateBinding;
+        return  value?.__$isTemplateBinding;
     },
     isObservableWhenResult(value) {
         return value && (value.__$isObservableWhen || (typeof value === 'object' && '$target' in value && '$observer' in value));

package/src/core/wrappers/ElementCreator.js

@@ -59,8 +59,9 @@ export const ElementCreator = {
      */
     createElement(name)  {
         if(name) {
-            if($nodeCache.has(name)) {
-                return $nodeCache.get(name).cloneNode();
+            const cacheNode = $nodeCache.get(name);
+            if(cacheNode) {
+                return cacheNode.cloneNode();
             }
             const node = document.createElement(name);
             $nodeCache.set(name, node);
@@ -75,12 +76,16 @@ export const ElementCreator = {
      */
     processChildren(children, parent) {
         if(children === null) return;
-        PluginsManager.emit('BeforeProcessChildren', parent);
+        if(process.env.NODE_ENV === 'development') {
+            PluginsManager.emit('BeforeProcessChildren', parent);
+        }
         let child = this.getChild(children);
         if(child) {
             parent.appendChild(child);
         }
-        PluginsManager.emit('AfterProcessChildren', parent);
+        if(process.env.NODE_ENV === 'development') {
+            PluginsManager.emit('AfterProcessChildren', parent);
+        }
     },
     getChild(child) {
         if(child == null) {
@@ -103,20 +108,8 @@ export const ElementCreator = {
      * @param {Object} attributes
      */
     processAttributes(element, attributes) {
-        if(Validator.isFragment(element)) return;
         if (attributes) {
             AttributesWrapper(element, attributes);
         }
-    },
-    /**
-     *
-     * @param {HTMLElement} element
-     * @param {Object} attributes
-     * @param {?Function} customWrapper
-     * @returns {HTMLElement|DocumentFragment}
-     */
-    setup(element, attributes, customWrapper) {
-        PluginsManager.emit('Setup', element, attributes, customWrapper);
-        return element;
     }
 };

package/src/core/wrappers/HtmlElementWrapper.js

@@ -20,14 +20,9 @@ function createHtmlElement($tagName, customWrapper, _attributes, _children = nul
     let element = ElementCreator.createElement($tagName);
     let finalElement = (customWrapper && typeof customWrapper === 'function') ? customWrapper(element) : element;
 
-    if(attributes) {
-        ElementCreator.processAttributes(finalElement, attributes);
-    }
-    if(children) {
-        ElementCreator.processChildren(children, finalElement);
-    }
-
-    return ElementCreator.setup(finalElement, attributes, customWrapper);
+    ElementCreator.processAttributes(finalElement, attributes);
+    ElementCreator.processChildren(children, finalElement);
+    return finalElement;
 }
 
 /**

package/src/core/wrappers/NDElement.js

@@ -6,7 +6,9 @@ import DebugManager from "../utils/debug-manager.js";
 export function NDElement(element) {
     this.$element = element;
     this.$observer = null;
-    PluginsManager.emit('NDElementCreated', element, this);
+    if(process.env.NODE_ENV === 'development') {
+        PluginsManager.emit('NDElementCreated', element, this);
+    }
 }
 
 NDElement.prototype.__$isNDElement = true;
@@ -175,8 +177,9 @@ NDElement.extend = function(methods) {
 
         NDElement.prototype[name] = method;
     }
-
-    PluginsManager.emit('NDElementExtended', methods);
+    if(process.env.NODE_ENV === 'development') {
+        PluginsManager.emit('NDElementExtended', methods);
+    }
 
     return NDElement;
 };

package/src/core/wrappers/prototypes/nd-element-extensions.js

@@ -49,7 +49,9 @@ Array.prototype.toNdElement = function () {
 
 Function.prototype.toNdElement = function () {
     const child = this;
-    PluginsManager.emit('BeforeProcessComponent', child);
+    if(process.env.NODE_ENV === 'development') {
+        PluginsManager.emit('BeforeProcessComponent', child);
+    }
     return ElementCreator.getChild(child());
 };