native-document 1.0.89 → 1.0.91

package/src/core/data/ObservableItem.js

@@ -57,7 +57,7 @@ ObservableItem.prototype.intercept = function(callback) {
 };
 
 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) {
@@ -67,25 +67,24 @@ ObservableItem.prototype.triggerListeners = function(operations) {
 
     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() {
@@ -97,12 +96,12 @@ ObservableItem.prototype.triggerWatchers = function() {
     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);
     }
 };
@@ -114,7 +113,7 @@ ObservableItem.prototype.triggerAll = function(operations) {
 
 ObservableItem.prototype.triggerWatchersAndFirstListener = function(operations) {
     this.triggerWatchers();
-    this.triggerListeners(operations);
+    this.triggerFirstListener(operations);
 };
 
 ObservableItem.prototype.assocTrigger = function() {
@@ -213,11 +212,10 @@ ObservableItem.prototype.cleanup = function() {
 /**
  *
  * @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.');
@@ -227,15 +225,13 @@ ObservableItem.prototype.subscribe = function(callback, context = null, target =
         throw new NativeDocumentError('Callback must be a function');
     }
 
-
-    const finalCallback = { callback, context };
-    this.$listeners.push(finalCallback);
+    this.$listeners.push(callback);
     this.assocTrigger();
     if(process.env.NODE_ENV === 'development') {
         PluginsManager.emit('ObservableSubscribe', this, target);
     }
     return () => {
-        this.unsubscribe(finalCallback);
+        this.unsubscribe(callback);
         this.assocTrigger();
         if(process.env.NODE_ENV === 'development') {
             PluginsManager.emit('ObservableUnsubscribe', this);
@@ -243,24 +239,23 @@ ObservableItem.prototype.subscribe = function(callback, context = null, target =
     };
 };
 
-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]);
@@ -315,12 +310,6 @@ ObservableItem.prototype.when = function(value) {
     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;

package/src/core/data/ObservableWhen.js

@@ -6,8 +6,8 @@ export const ObservableWhen = function(observer, value) {
 
 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() {

package/src/core/wrappers/AttributesWrapper.js

@@ -1,30 +1,24 @@
 import Validator from "../utils/validator";
+import NativeDocumentError from "../errors/NativeDocumentError";
 import {BOOLEAN_ATTRIBUTES} from "./constants.js";
 import {Observable} from "../data/Observable";
 
-export const handleElementAttributeClass = function(shouldAdd, _, __, context) {
-    context.element.classes.toggle(context.className, shouldAdd);
-};
 /**
  *
  * @param {HTMLElement} element
  * @param {Object} data
  */
 export function bindClassAttribute(element, data) {
-    const classNames = Object.keys(data);
-
-    for(let i = 0, length = classNames.length; i < length; i++) {
-        const className = classNames[i];
+    for(const className in data) {
         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) {
@@ -33,6 +27,7 @@ export function bindClassAttribute(element, data) {
         }
         element.classes.toggle(className, value)
     }
+    data = null;
 }
 
 /**
@@ -41,9 +36,7 @@ export function bindClassAttribute(element, data) {
  * @param {Object} data
  */
 export function bindStyleAttribute(element, data) {
-    const keys = Object.keys(data)
-    for(let i = 0, length = keys.length; i < length; i++) {
-        const styleName = keys[i];
+    for(const styleName in data) {
         const value = data[styleName];
         if(value.__$isObservable) {
             element.style[styleName] = value.val();
@@ -63,8 +56,7 @@ export function bindStyleAttribute(element, data) {
 export 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 {
@@ -72,13 +64,13 @@ export function bindBooleanAttribute(element, attributeName, value) {
     }
     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));
@@ -93,14 +85,14 @@ export function bindBooleanAttribute(element, attributeName, value) {
  * @param {Observable} value
  */
 export 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());
 }
 
@@ -111,13 +103,9 @@ export function bindAttributeWithObservable(element, attributeName, value) {
  */
 export default function AttributesWrapper(element, attributes) {
 
-    if(process.env.NODE_ENV === 'development') {
-        Validator.validateAttributes(attributes);
-    }
-    const attributeNames = Object.keys(attributes);
+    Validator.validateAttributes(attributes);
 
-    for(let i = 0, length = attributeNames.length; i < length; i++) {
-        const originalAttributeName = attributeNames[i];
+    for(const originalAttributeName in attributes) {
         const attributeName = originalAttributeName.toLowerCase();
         let value = attributes[originalAttributeName];
         if(value == null) {
@@ -142,10 +130,6 @@ export default function AttributesWrapper(element, attributes) {
             continue;
         }
 
-        if(attributeName === 'value') {
-            element.value = value;
-            continue;
-        }
         element.setAttribute(attributeName, value);
     }
     return element;

package/src/core/wrappers/prototypes/bind-class-extensions.js

@@ -1,20 +1,16 @@
 import ObservableItem from "../../../core/data/ObservableItem";
+import {toggleElementClass} from "../AttributesWrapper";
 import {ObservableWhen} from "../../data/ObservableWhen";
 import TemplateBinding from "../../../core/wrappers/TemplateBinding";
 
-
-export const handleElementAttributeClass = function(shouldAdd, _, __, context) {
-    context.element.classes.toggle(context.className, shouldAdd);
-};
-
 ObservableItem.prototype.bindNdClass = function(element, className) {
     element.classes.toggle(className, this.val());
-    this.subscribe(handleElementAttributeClass, { element, className });
+    this.subscribe((shouldAdd) => element.classes.toggle(className, shouldAdd));
 };
 
 ObservableWhen.prototype.bindNdClass = function(element, className) {
     element.classes.toggle(className, this.isMath());
-    this.subscribe(handleElementAttributeClass, { element, className });
+    this.subscribe((shouldAdd) => element.classes.toggle(className, shouldAdd));
 };
 
 TemplateBinding.prototype.bindNdClass = function(element, className) {