native-document 1.0.89 → 1.0.90

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

@@ -334,10 +334,10 @@ var NativeComponents = (function (exports) {
 
     ObservableChecker.prototype.__$isObservableChecker = true;
 
-    ObservableChecker.prototype.subscribe = function(callback, context = null) {
-        const unSubscribe = this.observable.subscribe((value, _, __) => {
-            callback && callback(this.checker(value), _, __, context);
-        }, context);
+    ObservableChecker.prototype.subscribe = function(callback) {
+        const unSubscribe = this.observable.subscribe((value) => {
+            callback && callback(this.checker(value));
+        });
         this.unSubscriptions.push(unSubscribe);
         return unSubscribe;
     };
@@ -369,8 +369,8 @@ var NativeComponents = (function (exports) {
 
     ObservableWhen.prototype.__$isObservableWhen = true;
 
-    ObservableWhen.prototype.subscribe = function(callback, context = null) {
-        return this.$observer.on(this.$target, callback, context);
+    ObservableWhen.prototype.subscribe = function(callback) {
+        return this.$observer.on(this.$target, callback);
     };
 
     ObservableWhen.prototype.val = function() {
@@ -508,7 +508,7 @@ var NativeComponents = (function (exports) {
     };
 
     ObservableItem.prototype.triggerFirstListener = function(operations) {
-        this.$firstListener.callback(this.$currentValue, this.$previousValue, operations || {}, this.$firstListener.context);
+        this.$firstListener(this.$currentValue, this.$previousValue, operations || {});
     };
 
     ObservableItem.prototype.triggerListeners = function(operations) {
@@ -518,25 +518,24 @@ var NativeComponents = (function (exports) {
 
         operations = operations || DEFAULT_OPERATIONS;
         for(let i = 0, length = $listeners.length; i < length; i++) {
-            const listener = $listeners[i];
-            listener.callback($currentValue, $previousValue, operations, listener.context);
+            $listeners[i]($currentValue, $previousValue, operations);
         }
     };
 
     const handleWatcherCallback = function(callbacks, value) {
-        if(callbacks.callback) {
-            callbacks.callback(value, null, null, callbacks.context);
+        if(typeof callbacks === "function") {
+            callbacks(value);
             return;
         }
         if (callbacks.set) {
             callbacks.set(value);
             return;
         }
-        callbacks.forEach(callback => {
-            callback.callback
-                ? callback.callback(value, null, null, callback.context)
-                : callback.set(value);
-        });
+        for(let i = 0, length = callbacks.length; i < length; i++) {
+            const callback = callbacks[i];
+            callback.set ? callback.set(value) : callback(value);
+
+        }
     };
 
     ObservableItem.prototype.triggerWatchers = function() {
@@ -548,12 +547,12 @@ var NativeComponents = (function (exports) {
         const $previousValue = this.$previousValue;
         const $currentValue = this.$currentValue;
 
-        if($watchers.has($currentValue)) {
-            const $currentValueCallbacks = $watchers.get($currentValue);
+        const $currentValueCallbacks = $watchers.get($currentValue);
+        const $previousValueCallbacks = $watchers.get($previousValue);
+        if($currentValueCallbacks) {
             handleWatcherCallback($currentValueCallbacks, true);
         }
-        if($watchers.has($previousValue)) {
-            const $previousValueCallbacks = $watchers.get($previousValue);
+        if($previousValueCallbacks) {
             handleWatcherCallback($previousValueCallbacks, false);
         }
     };
@@ -565,7 +564,7 @@ var NativeComponents = (function (exports) {
 
     ObservableItem.prototype.triggerWatchersAndFirstListener = function(operations) {
         this.triggerWatchers();
-        this.triggerListeners(operations);
+        this.triggerFirstListener(operations);
     };
 
     ObservableItem.prototype.assocTrigger = function() {
@@ -658,11 +657,10 @@ var NativeComponents = (function (exports) {
     /**
      *
      * @param {Function} callback
-     * @param {?Object} context
      * @param {any} target
      * @returns {(function(): void)}
      */
-    ObservableItem.prototype.subscribe = function(callback, context = null, target = null) {
+    ObservableItem.prototype.subscribe = function(callback, target = null) {
         this.$listeners = this.$listeners ?? [];
         if (this.$isCleanedUp) {
             DebugManager.warn('Observable subscription', '⚠️ Attempted to subscribe to a cleaned up observable.');
@@ -672,34 +670,31 @@ var NativeComponents = (function (exports) {
             throw new NativeDocumentError('Callback must be a function');
         }
 
-
-        const finalCallback = { callback, context };
-        this.$listeners.push(finalCallback);
+        this.$listeners.push(callback);
         this.assocTrigger();
         return () => {
-            this.unsubscribe(finalCallback);
+            this.unsubscribe(callback);
             this.assocTrigger();
         };
     };
 
-    ObservableItem.prototype.on = function(value, callback, context = null) {
+    ObservableItem.prototype.on = function(value, callback) {
         this.$watchers = this.$watchers ?? new Map();
 
         let watchValueList = this.$watchers.get(value);
-        const finalCallback = { callback, context };
 
         if(!watchValueList) {
-            this.$watchers.set(value, finalCallback);
+            this.$watchers.set(value, callback);
         } else if(!Validator.isArray(watchValueList)) {
-            watchValueList = [watchValueList, finalCallback];
+            watchValueList = [watchValueList, callback];
             this.$watchers.set(value, watchValueList);
         } else {
-            watchValueList.push(finalCallback);
+            watchValueList.push(callback);
         }
 
         this.assocTrigger();
         return () => {
-            const index = watchValueList.indexOf(finalCallback);
+            const index = watchValueList.indexOf(callback);
             watchValueList?.splice(index, 1);
             if(watchValueList.size === 1) {
                 this.$watchers.set(value, watchValueList[0]);
@@ -754,12 +749,6 @@ var NativeComponents = (function (exports) {
         return new ObservableWhen(this, value);
     };
 
-    ObservableItem.prototype.toString = function() {
-        if(!this.$memoryId) {
-            MemoryManager.register(this);
-        }
-        return '{{#ObItem::(' +this.$memoryId+ ')}}';
-    };
     ObservableItem.prototype.equals = function(other) {
         if(Validator.isObservable(other)) {
             return this.$currentValue === other.$currentValue;
@@ -1431,9 +1420,6 @@ var NativeComponents = (function (exports) {
         setInterval(() => MemoryManager.cleanObservables(threshold), interval);
     };
 
-    const handleElementAttributeClass = function(shouldAdd, _, __, context) {
-        context.element.classes.toggle(context.className, shouldAdd);
-    };
     /**
      *
      * @param {HTMLElement} element
@@ -1441,19 +1427,17 @@ var NativeComponents = (function (exports) {
      */
     function bindClassAttribute(element, 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(value.__$isObservable) {
                 element.classes.toggle(className, value.val());
-                value.subscribe(handleElementAttributeClass, { element, className });
-                // value.subscribe((shouldAdd) => element.classes.toggle(className, shouldAdd));
+                value.subscribe((shouldAdd) => element.classes.toggle(className, shouldAdd));
                 continue;
             }
             if(value.__$isObservableWhen) {
                 element.classes.toggle(className, value.isMath());
-                value.subscribe(handleElementAttributeClass, { element, className });
+                value.subscribe((shouldAdd) => element.classes.toggle(className, shouldAdd));
                 continue;
             }
             if(value.$hydrate) {
@@ -1462,6 +1446,7 @@ var NativeComponents = (function (exports) {
             }
             element.classes.toggle(className, value);
         }
+        data = null;
     }
 
     /**
@@ -1492,8 +1477,7 @@ var NativeComponents = (function (exports) {
     function bindBooleanAttribute(element, attributeName, value) {
         const isObservable = value.__$isObservable;
         const defaultValue = isObservable? value.val() : value;
-        const isBoolValue = typeof defaultValue === "boolean";
-        if(isBoolValue) {
+        if(Validator.isBoolean(defaultValue)) {
             element[attributeName] = defaultValue;
         }
         else {
@@ -1501,13 +1485,13 @@ var NativeComponents = (function (exports) {
         }
         if(isObservable) {
             if(attributeName === 'checked') {
-                if(isBoolValue) {
+                if(typeof defaultValue === 'boolean') {
                     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));
+                else {
+                    element.addEventListener('input', () => value.set(element.value));
+                }
+                value.subscribe((newValue) => element[attributeName] = newValue);
                 return;
             }
             value.subscribe((newValue) => element[attributeName] = (newValue === element.value));
@@ -1522,14 +1506,14 @@ var NativeComponents = (function (exports) {
      * @param {Observable} value
      */
     function bindAttributeWithObservable(element, attributeName, value) {
+        const applyValue = attributeName === 'value' ? (newValue) => element.value = newValue : (newValue) => element.setAttribute(attributeName, newValue);
+        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());
     }
 
@@ -1539,10 +1523,10 @@ var NativeComponents = (function (exports) {
      * @param {Object} attributes
      */
     function AttributesWrapper(element, attributes) {
-        const attributeNames = Object.keys(attributes);
+        const attributesKeys = Object.keys(attributes);
 
-        for(let i = 0, length = attributeNames.length; i < length; i++) {
-            const originalAttributeName = attributeNames[i];
+        for(let i = 0, length = attributesKeys.length; i < length; i++) {
+            const originalAttributeName = attributesKeys[i];
             const attributeName = originalAttributeName.toLowerCase();
             let value = attributes[originalAttributeName];
             if(value == null) {
@@ -1567,10 +1551,6 @@ var NativeComponents = (function (exports) {
                 continue;
             }
 
-            if(attributeName === 'value') {
-                element.value = value;
-                continue;
-            }
             element.setAttribute(attributeName, value);
         }
         return element;