native-document 1.0.87 → 1.0.89

package/dist/native-document.dev.js

@@ -1,10 +1,10 @@
 var NativeDocument = (function (exports) {
     'use strict';
 
-    let DebugManager = {};
+    let DebugManager$1 = {};
 
     {
-        DebugManager = {
+        DebugManager$1 = {
             enabled: false,
 
             enable() {
@@ -35,7 +35,7 @@ var NativeDocument = (function (exports) {
         };
 
     }
-    var DebugManager$1 = DebugManager;
+    var DebugManager = DebugManager$1;
 
     const MemoryManager = (function() {
 
@@ -84,7 +84,7 @@ var NativeDocument = (function (exports) {
                     }
                 }
                 if (cleanedCount > 0) {
-                    DebugManager$1.log('Memory Auto Clean', `🧹 Cleaned ${cleanedCount} orphaned observables`);
+                    DebugManager.log('Memory Auto Clean', `🧹 Cleaned ${cleanedCount} orphaned observables`);
                 }
             }
         };
@@ -113,10 +113,10 @@ var NativeDocument = (function (exports) {
 
     ObservableChecker.prototype.__$isObservableChecker = true;
 
-    ObservableChecker.prototype.subscribe = function(callback) {
-        const unSubscribe = this.observable.subscribe((value) => {
-            callback && callback(this.checker(value));
-        });
+    ObservableChecker.prototype.subscribe = function(callback, context = null) {
+        const unSubscribe = this.observable.subscribe((value, _, __) => {
+            callback && callback(this.checker(value), _, __, context);
+        }, context);
         this.unSubscriptions.push(unSubscribe);
         return unSubscribe;
     };
@@ -210,7 +210,7 @@ var NativeDocument = (function (exports) {
                             try{
                                 callback.call(plugin, ...data);
                             } catch (error) {
-                                DebugManager$1.error('Plugin Manager', `Error in plugin ${plugin.$name} for event ${eventName}`, error);
+                                DebugManager.error('Plugin Manager', `Error in plugin ${plugin.$name} for event ${eventName}`, error);
                             }
                         }
                     }
@@ -228,8 +228,8 @@ var NativeDocument = (function (exports) {
 
     ObservableWhen.prototype.__$isObservableWhen = true;
 
-    ObservableWhen.prototype.subscribe = function(callback) {
-        return this.$observer.on(this.$target, callback);
+    ObservableWhen.prototype.subscribe = function(callback, context = null) {
+        return this.$observer.on(this.$target, callback, context);
     };
 
     ObservableWhen.prototype.val = function() {
@@ -365,7 +365,7 @@ var NativeDocument = (function (exports) {
     };
 
     ObservableItem.prototype.triggerFirstListener = function(operations) {
-        this.$firstListener(this.$currentValue, this.$previousValue, operations || {});
+        this.$firstListener.callback(this.$currentValue, this.$previousValue, operations || {}, this.$firstListener.context);
     };
 
     ObservableItem.prototype.triggerListeners = function(operations) {
@@ -375,14 +375,14 @@ var NativeDocument = (function (exports) {
 
         operations = operations || DEFAULT_OPERATIONS;
         for(let i = 0, length = $listeners.length; i < length; i++) {
-            $listeners[i];
-            $listeners[i]($currentValue, $previousValue, operations);
+            const listener = $listeners[i];
+            listener.callback($currentValue, $previousValue, operations, listener.context);
         }
     };
 
     const handleWatcherCallback = function(callbacks, value) {
-        if(typeof callbacks === "function") {
-            callbacks(value);
+        if(callbacks.callback) {
+            callbacks.callback(value, null, null, callbacks.context);
             return;
         }
         if (callbacks.set) {
@@ -390,7 +390,9 @@ var NativeDocument = (function (exports) {
             return;
         }
         callbacks.forEach(callback => {
-            callback.set ? callback.set(value) : callback(value);
+            callback.callback
+                ? callback.callback(value, null, null, callback.context)
+                : callback.set(value);
         });
     };
 
@@ -519,26 +521,29 @@ var NativeDocument = (function (exports) {
     /**
      *
      * @param {Function} callback
+     * @param {?Object} context
      * @param {any} target
      * @returns {(function(): void)}
      */
-    ObservableItem.prototype.subscribe = function(callback, target = null) {
+    ObservableItem.prototype.subscribe = function(callback, context = null, target = null) {
         this.$listeners = this.$listeners ?? [];
         if (this.$isCleanedUp) {
-            DebugManager$1.warn('Observable subscription', '⚠️ Attempted to subscribe to a cleaned up observable.');
+            DebugManager.warn('Observable subscription', '⚠️ Attempted to subscribe to a cleaned up observable.');
             return () => {};
         }
         if (typeof callback !== 'function') {
             throw new NativeDocumentError('Callback must be a function');
         }
 
-        this.$listeners.push(callback);
+
+        const finalCallback = { callback, context };
+        this.$listeners.push(finalCallback);
         this.assocTrigger();
         {
             PluginsManager.emit('ObservableSubscribe', this, target);
         }
         return () => {
-            this.unsubscribe(callback);
+            this.unsubscribe(finalCallback);
             this.assocTrigger();
             {
                 PluginsManager.emit('ObservableUnsubscribe', this);
@@ -546,24 +551,24 @@ var NativeDocument = (function (exports) {
         };
     };
 
-    ObservableItem.prototype.on = function(value, callback) {
+    ObservableItem.prototype.on = function(value, callback, context = null) {
         this.$watchers = this.$watchers ?? new Map();
 
         let watchValueList = this.$watchers.get(value);
+        const finalCallback = { callback, context };
 
         if(!watchValueList) {
-            this.$watchers.set(value, callback);
+            this.$watchers.set(value, finalCallback);
         } else if(!Validator.isArray(watchValueList)) {
-            watchValueList = [watchValueList];
+            watchValueList = [watchValueList, finalCallback];
             this.$watchers.set(value, watchValueList);
-            return;
         } else {
-            watchValueList.push(callback);
+            watchValueList.push(finalCallback);
         }
 
         this.assocTrigger();
         return () => {
-            const index = watchValueList.indexOf(callback);
+            const index = watchValueList.indexOf(finalCallback);
             watchValueList?.splice(index, 1);
             if(watchValueList.size === 1) {
                 this.$watchers.set(value, watchValueList[0]);
@@ -884,7 +889,7 @@ var NativeDocument = (function (exports) {
             }
             {
                 if (this[name] && !this.$localExtensions.has(name)) {
-                    DebugManager$1.warn('NDElement.extend', `Method "${name}" already exists and will be overwritten`);
+                    DebugManager.warn('NDElement.extend', `Method "${name}" already exists and will be overwritten`);
                 }
                 this.$localExtensions.set(name, method);
             }
@@ -918,17 +923,17 @@ var NativeDocument = (function (exports) {
             const method = methods[name];
 
             if (typeof method !== 'function') {
-                DebugManager$1.warn('NDElement.extend', `"${name}" is not a function, skipping`);
+                DebugManager.warn('NDElement.extend', `"${name}" is not a function, skipping`);
                 continue;
             }
 
             if (protectedMethods.has(name)) {
-                DebugManager$1.error('NDElement.extend', `Cannot override protected method "${name}"`);
+                DebugManager.error('NDElement.extend', `Cannot override protected method "${name}"`);
                 throw new NativeDocumentError(`Cannot override protected method "${name}"`);
             }
 
             if (NDElement.prototype[name]) {
-                DebugManager$1.warn('NDElement.extend', `Overwriting existing prototype method "${name}"`);
+                DebugManager.warn('NDElement.extend', `Overwriting existing prototype method "${name}"`);
             }
 
             NDElement.prototype[name] = method;
@@ -1087,7 +1092,7 @@ var NativeDocument = (function (exports) {
             const foundReserved = Object.keys(attributes).filter(key => reserved.includes(key));
 
             if (foundReserved.length > 0) {
-                DebugManager$1.warn('Validator', `Reserved attributes found: ${foundReserved.join(', ')}`);
+                DebugManager.warn('Validator', `Reserved attributes found: ${foundReserved.join(', ')}`);
             }
 
             return attributes;
@@ -1135,7 +1140,7 @@ var NativeDocument = (function (exports) {
         anchorFragment.appendChild = function(child, before = null) {
             const parent = anchorEnd.parentNode;
             if(!parent) {
-                DebugManager$1.error('Anchor', 'Anchor : parent not found', child);
+                DebugManager.error('Anchor', 'Anchor : parent not found', child);
                 return;
             }
             before = before ?? anchorEnd;
@@ -1349,60 +1354,29 @@ var NativeDocument = (function (exports) {
         setInterval(() => MemoryManager.cleanObservables(threshold), interval);
     };
 
-    ObservableItem.prototype.bindNdClass = function(element, className) {
-        element.classes.toggle(className, this.val());
-        this.subscribe(toggleElementClass.bind(null, element, className));
+    const handleElementAttributeClass = function(shouldAdd, _, __, context) {
+        context.element.classes.toggle(context.className, shouldAdd);
     };
-
-    ObservableWhen.prototype.bindNdClass = function(element, className) {
-        element.classes.toggle(className, this.isMath());
-        this.subscribe(toggleElementClass.bind(null, element, className));
-    };
-
-    TemplateBinding.prototype.bindNdClass = function(element, className) {
-        this.$hydrate(element, className);
-    };
-
-    function toggleElementClass(element, className, shouldAdd) {
-        element.classes.toggle(className, shouldAdd);
-    }
-
-    function toggleElementStyle(element, styleName, newValue) {
-        element.style[styleName] = newValue;
-    }
-
-    function updateInputFromObserver(element, attributeName, newValue) {
-        if(Validator.isBoolean(newValue)) {
-            element[attributeName] = newValue;
-            return;
-        }
-        element[attributeName] = newValue === element.value;
-    }
-
-    function updateObserverFromInput(element, attributeName, defaultValue, value) {
-        if(Validator.isBoolean(defaultValue)) {
-            value.set(element[attributeName]);
-            return;
-        }
-        value.set(element.value);
-    }
-
     /**
      *
      * @param {HTMLElement} element
      * @param {Object} data
      */
     function bindClassAttribute(element, data) {
-        for(let className in data) {
+        const classNames = Object.keys(data);
+
+        for(let i = 0, length = classNames.length; i < length; i++) {
+            const className = classNames[i];
             const value = data[className];
-            if(Validator.isObservable(value)) {
+            if(value.__$isObservable) {
                 element.classes.toggle(className, value.val());
-                value.subscribe(toggleElementClass.bind(null, element, className));
+                value.subscribe(handleElementAttributeClass, { element, className });
+                // value.subscribe((shouldAdd) => element.classes.toggle(className, shouldAdd));
                 continue;
             }
-            if(Validator.isObservableWhenResult(value)) {
+            if(value.__$isObservableWhen) {
                 element.classes.toggle(className, value.isMath());
-                value.subscribe(toggleElementClass.bind(null, element, className));
+                value.subscribe(handleElementAttributeClass, { element, className });
                 continue;
             }
             if(value.$hydrate) {
@@ -1411,7 +1385,6 @@ var NativeDocument = (function (exports) {
             }
             element.classes.toggle(className, value);
         }
-        data = null;
     }
 
     /**
@@ -1420,11 +1393,13 @@ var NativeDocument = (function (exports) {
      * @param {Object} data
      */
     function bindStyleAttribute(element, data) {
-        for(let styleName in data) {
+        const keys = Object.keys(data);
+        for(let i = 0, length = keys.length; i < length; i++) {
+            const styleName = keys[i];
             const value = data[styleName];
-            if(Validator.isObservable(value)) {
+            if(value.__$isObservable) {
                 element.style[styleName] = value.val();
-                value.subscribe(toggleElementStyle.bind(null, element, styleName));
+                value.subscribe((newValue) => element.style[styleName] = newValue);
                 continue;
             }
             element.style[styleName] = value;
@@ -1438,18 +1413,27 @@ var NativeDocument = (function (exports) {
      * @param {boolean|number|Observable} value
      */
     function bindBooleanAttribute(element, attributeName, value) {
-        const defaultValue = Validator.isObservable(value) ? value.val() : value;
-        if(Validator.isBoolean(defaultValue)) {
+        const isObservable = value.__$isObservable;
+        const defaultValue = isObservable? value.val() : value;
+        const isBoolValue = typeof defaultValue === "boolean";
+        if(isBoolValue) {
             element[attributeName] = defaultValue;
         }
         else {
             element[attributeName] = defaultValue === element.value;
         }
-        if(Validator.isObservable(value)) {
-            if(['checked'].includes(attributeName)) {
-                element.addEventListener('input', updateObserverFromInput.bind(null, element, attributeName, defaultValue, value));
+        if(isObservable) {
+            if(attributeName === 'checked') {
+                if(isBoolValue) {
+                    element.addEventListener('input', () => value.set(element[attributeName]));
+                    value.subscribe((newValue) => element[attributeName] = newValue);
+                    return;
+                }
+                element.addEventListener('input', () => value.set(element.value));
+                value.subscribe((newValue) => element[attributeName] = (newValue === element.value));
+                return;
             }
-            value.subscribe(updateInputFromObserver.bind(null, element, attributeName));
+            value.subscribe((newValue) => element[attributeName] = (newValue === element.value));
         }
     }
 
@@ -1461,19 +1445,15 @@ var NativeDocument = (function (exports) {
      * @param {Observable} value
      */
     function bindAttributeWithObservable(element, attributeName, value) {
-        const applyValue = (newValue) => {
-            if(attributeName === 'value') {
-                element.value = newValue;
-                return;
-            }
-            element.setAttribute(attributeName, newValue);
-        };
-        applyValue(value.val());
-        value.subscribe(applyValue);
-
         if(attributeName === 'value') {
+            value.subscribe((newValue) => element.value = newValue);
+            element.value = value.val();
             element.addEventListener('input', () => value.set(element.value));
+            return;
         }
+
+        value.subscribe((newValue) => element.setAttribute(attributeName, newValue));
+        element.setAttribute(attributeName, value.val());
     }
 
     /**
@@ -1483,15 +1463,15 @@ var NativeDocument = (function (exports) {
      */
     function AttributesWrapper(element, attributes) {
 
-        Validator.validateAttributes(attributes);
-
-        if(!Validator.isObject(attributes)) {
-            throw new NativeDocumentError('Attributes must be an object');
+        {
+            Validator.validateAttributes(attributes);
         }
+        const attributeNames = Object.keys(attributes);
 
-        for(let key in attributes) {
-            const attributeName = key.toLowerCase();
-            let value = attributes[attributeName];
+        for(let i = 0, length = attributeNames.length; i < length; i++) {
+            const originalAttributeName = attributeNames[i];
+            const attributeName = originalAttributeName.toLowerCase();
+            let value = attributes[originalAttributeName];
             if(value == null) {
                 continue;
             }
@@ -1514,6 +1494,10 @@ var NativeDocument = (function (exports) {
                 continue;
             }
 
+            if(attributeName === 'value') {
+                element.value = value;
+                continue;
+            }
             element.setAttribute(attributeName, value);
         }
         return element;
@@ -1654,6 +1638,14 @@ var NativeDocument = (function (exports) {
             }
             return Anchor('Fragment');
         },
+        bindTextNode(textNode, value) {
+            if(value?.__$isObservable) {
+                value.subscribe(newValue => textNode.nodeValue = newValue);
+                textNode.nodeValue = value.val();
+                return;
+            }
+            textNode.nodeValue = value;
+        },
         /**
          *
          * @param {*} children
@@ -2189,9 +2181,8 @@ var NativeDocument = (function (exports) {
 
 
     const applyBindingTreePath = (root, target, data, path) => {
-        let newTarget = null;
         if(path.fn) {
-            newTarget = path.fn(data, target, root);
+            path.fn(data, target, root);
         }
         if(path.children) {
             for(let i = 0, length = path.children.length; i < length; i++) {
@@ -2200,7 +2191,6 @@ var NativeDocument = (function (exports) {
                 applyBindingTreePath(root, pathTargetNode, data, currentPath);
             }
         }
-        return newTarget;
     };
 
     function TemplateCloner($fn) {
@@ -2216,15 +2206,10 @@ var NativeDocument = (function (exports) {
             const bindDingData = cloneBindingsDataCache.get(node);
             if(node.nodeType === 3) {
                 if(bindDingData && bindDingData.value) {
-                    currentPath.fn = (data, targetNode, currentRoot) => {
-                        const newNode = bindDingData.value(data);
-                        if (targetNode === currentRoot) {
-                            return newNode;
-                        }
-                        targetNode.replaceWith(newNode);
-                        return null;
-                    };
-                    return bindDingData.value(data);
+                    currentPath.fn = bindDingData.value;
+                    const textNode = node.cloneNode();
+                    bindDingData.value(data, textNode);
+                    return textNode;
                 }
                 return node.cloneNode(true);
             }
@@ -2261,11 +2246,7 @@ var NativeDocument = (function (exports) {
         const cloneWithBindingPaths = (data) => {
             let root = $node.cloneNode(true);
 
-            const newRoot = applyBindingTreePath(root, root, data, $bindingTreePath);
-            if(newRoot) {
-                root = newRoot;
-            }
-
+            applyBindingTreePath(root, root, data, $bindingTreePath);
             return root;
         };
 
@@ -2300,13 +2281,13 @@ var NativeDocument = (function (exports) {
         };
         this.value = (callbackOrProperty) => {
             if(typeof callbackOrProperty !== 'function') {
-                return createBinding(function(data) {
+                return createBinding(function(data, textNode) {
                     const firstArgument = data[0];
-                    return createTextNode(firstArgument[callbackOrProperty]);
+                    ElementCreator.bindTextNode(textNode, firstArgument[callbackOrProperty]);
                 }, 'value');
             }
-            return createBinding(function(data) {
-                return createTextNode(callbackOrProperty(...data));
+            return createBinding(function(data, textNode) {
+                ElementCreator.bindTextNode(textNode, callbackOrProperty(...data));
             }, 'value');
         };
         this.attr = (fn) => {
@@ -3466,7 +3447,7 @@ var NativeDocument = (function (exports) {
                 }
                 cache.set(keyId, { keyId, isNew: true, child: new WeakRef(child), indexObserver});
             } catch (e) {
-                DebugManager$1.error('ForEach', `Error creating element for key ${keyId}` , e);
+                DebugManager.error('ForEach', `Error creating element for key ${keyId}` , e);
                 throw e;
             }
             return keyId;
@@ -3812,7 +3793,7 @@ var NativeDocument = (function (exports) {
      */
     const ShowIf = function(condition, child, { comment = null, shouldKeepInCache = true} = {}) {
         if(!(Validator.isObservable(condition)) && !Validator.isObservableWhenResult(condition)) {
-            return DebugManager$1.warn('ShowIf', "ShowIf : condition must be an Observable / "+comment, condition);
+            return DebugManager.warn('ShowIf', "ShowIf : condition must be an Observable / "+comment, condition);
         }
         const element = Anchor('Show if : '+(comment || ''));
 
@@ -4599,7 +4580,7 @@ var NativeDocument = (function (exports) {
                 window.history.pushState({ name: route.name(), params, path}, route.name() || path , path);
                 this.handleRouteChange(route, params, query, path);
             } catch (e) {
-                DebugManager$1.error('HistoryRouter', 'Error in pushState', e);
+                DebugManager.error('HistoryRouter', 'Error in pushState', e);
             }
         };
         /**
@@ -4612,7 +4593,7 @@ var NativeDocument = (function (exports) {
                 window.history.replaceState({ name: route.name(), params, path}, route.name() || path , path);
                 this.handleRouteChange(route, params, {}, path);
             } catch(e) {
-                DebugManager$1.error('HistoryRouter', 'Error in replaceState', e);
+                DebugManager.error('HistoryRouter', 'Error in replaceState', e);
             }
         };
         this.forward = function() {
@@ -4639,7 +4620,7 @@ var NativeDocument = (function (exports) {
                     }
                     this.handleRouteChange(route, params, query, path);
                 } catch(e) {
-                    DebugManager$1.error('HistoryRouter', 'Error in popstate event', e);
+                    DebugManager.error('HistoryRouter', 'Error in popstate event', e);
                 }
             });
             const { route, params, query, path } = this.resolve(defaultPath || (window.location.pathname+window.location.search));
@@ -4864,7 +4845,7 @@ var NativeDocument = (function (exports) {
                     listener(request);
                     next && next(request);
                 } catch (e) {
-                    DebugManager$1.warn('Route Listener', 'Error in listener:', e);
+                    DebugManager.warn('Route Listener', 'Error in listener:', e);
                 }
             }
         };
@@ -5023,7 +5004,7 @@ var NativeDocument = (function (exports) {
      */
     Router.create = function(options, callback) {
         if(!Validator.isFunction(callback)) {
-            DebugManager$1.error('Router', 'Callback must be a function', e);
+            DebugManager.error('Router', 'Callback must be a function', e);
             throw new RouterError('Callback must be a function');
         }
         const router = new Router(options);