@angular-wave/angular.ts 0.0.45 → 0.0.47

package/src/shared/jqlite/jqlite.js

@@ -10,7 +10,7 @@ import {
   isString,
   isUndefined,
   lowercase,
-  nodeName_,
+  getNodeName,
   shallowCopy,
 } from "../../shared/utils";
 import { CACHE, EXPANDO } from "../../core/cache/cache";
@@ -55,7 +55,6 @@ import { CACHE, EXPANDO } from "../../core/cache/cache";
  * - [`removeData()`](http://api.jquery.com/removeData/)
  * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
  * - [`text()`](http://api.jquery.com/text/)
- * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers
  * - [`val()`](http://api.jquery.com/val/)
  *
  * ## jQuery/jqLite Extras
@@ -136,7 +135,7 @@ const BOOLEAN_ELEMENTS = {};
  * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
  * and execution of chain functions.
  *
- * @param {string|Element|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+ * @param {string|Element|Comment|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
  * @returns {JQLite}
  */
 export function JQLite(element) {
@@ -261,7 +260,7 @@ JQLite.prototype.injector = function () {
  */
 JQLite.prototype.on = function (type, fn) {
   // Do not add event handlers to non-elements because they will not be cleaned up.
-  for (let i = 0, ii = this.length; i < ii; i++) {
+  for (let i = 0; i < this.length; i++) {
     const element = this[i];
     if (!elementAcceptsData(element)) {
       return;
@@ -311,7 +310,7 @@ JQLite.prototype.on = function (type, fn) {
  * @returns {JQLite}
  */
 JQLite.prototype.off = function (type, fn) {
-  for (let i = 0, ii = this.length; i < ii; i++) {
+  for (let i = 0; i < this.length; i++) {
     const element = this[i];
     const expandoStore = getExpando(element);
     const events = expandoStore && expandoStore.events;
@@ -357,7 +356,7 @@ JQLite.prototype.off = function (type, fn) {
  * @returns {JQLite}
  */
 JQLite.prototype.removeData = function (name) {
-  for (let i = 0, ii = this.length; i < ii; i++) {
+  for (let i = 0; i < this.length; i++) {
     const element = this[i];
     removeElementData(element, name);
   }
@@ -371,7 +370,7 @@ JQLite.prototype.removeData = function (name) {
  * @returns {JQLite|any}
  */
 JQLite.prototype.inheritedData = function (name, value) {
-  for (let i = 0, ii = this.length; i < ii; i++) {
+  for (let i = 0; i < this.length; i++) {
     const element = this[0];
     let res = getInheritedData(element, name, value);
     if (value) {
@@ -398,281 +397,382 @@ JQLite.prototype.html = function (value) {
   return this;
 };
 
-/// ///////////////////////////////////////
-// Functions iterating getter/setters.
-// these functions return self on setter and
-// value on get.
-/// ///////////////////////////////////////
-forEach(
-  {
-    data: getOrSetCacheData,
-    attr(element, name, value) {
-      let ret;
+/**
+ * Get the combined text contents of each element in the JQLite collection
+ * or set the text contents of all elements.
+ * @param {string} [value]
+ * @returns {JQLite|string}
+ */
+JQLite.prototype.text = function (value) {
+  let res = "";
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    if (isUndefined(value)) {
+      // read
       const { nodeType } = element;
-      if (
-        nodeType === Node.TEXT_NODE ||
-        nodeType === Node.ATTRIBUTE_NODE ||
-        nodeType === Node.COMMENT_NODE ||
-        !element.getAttribute
-      ) {
-        return;
-      }
+      res +=
+        nodeType === Node.ELEMENT_NODE || nodeType === Node.TEXT_NODE
+          ? element.textContent
+          : "";
+    } else {
+      // write
+      element.textContent = value;
+    }
+  }
 
-      const lowercasedName = lowercase(name);
-      const isBooleanAttr = BOOLEAN_ATTR[lowercasedName];
+  if (isUndefined(value)) {
+    return res;
+  } else {
+    return this;
+  }
+};
 
-      if (isDefined(value)) {
-        // setter
+/**
+ * Gets or sets the values of form elements such as input, select and textarea in a JQLite collection.
+ * @param {any} value
+ * @returns {JQLite|any}
+ */
+JQLite.prototype.val = function (value) {
+  // We can only get or set a value of
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    if (isUndefined(value)) {
+      // read
+      if (element.multiple && getNodeName(element) === "select") {
+        const result = [];
+        forEach(element.options, (option) => {
+          if (option.selected) {
+            result.push(option.value || option.text);
+          }
+        });
+        return result;
+      }
+      return element.value;
+    } else {
+      // write
+      element.value = value;
+      return this;
+    }
+  }
+};
 
-        if (value === null || (value === false && isBooleanAttr)) {
-          element.removeAttribute(name);
-        } else {
-          element.setAttribute(name, isBooleanAttr ? lowercasedName : value);
-        }
-      } else {
-        // getter
+/**
+ * @param {string|Object} name
+ * @param {any} value
+ * @returns
+ */
+JQLite.prototype.attr = function (name, value) {
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    let ret;
+    const { nodeType } = element;
+    if (
+      nodeType === Node.TEXT_NODE ||
+      nodeType === Node.ATTRIBUTE_NODE ||
+      nodeType === Node.COMMENT_NODE ||
+      !element.getAttribute
+    ) {
+      continue;
+    }
 
-        ret = element.getAttribute(name);
+    const lowercasedName = lowercase(name);
+    const isBooleanAttr = BOOLEAN_ATTR[lowercasedName];
 
-        if (isBooleanAttr && ret !== null) {
-          ret = lowercasedName;
-        }
-        // Normalize non-existing attributes to undefined (as jQuery).
-        return ret === null ? undefined : ret;
-      }
-    },
-    text: (function () {
-      getText.$dv = "";
-      return getText;
-
-      function getText(element, value) {
-        if (isUndefined(value)) {
-          const { nodeType } = element;
-          return nodeType === Node.ELEMENT_NODE || nodeType === Node.TEXT_NODE
-            ? element.textContent
-            : "";
-        }
-        element.textContent = value;
+    if (isObject(name)) {
+      for (let key in name) {
+        element.setAttribute(key, isBooleanAttr ? lowercasedName : name[key]);
       }
-    })(),
-    val(element, value) {
-      if (isUndefined(value)) {
-        if (element.multiple && nodeName_(element) === "select") {
-          const result = [];
-          forEach(element.options, (option) => {
-            if (option.selected) {
-              result.push(option.value || option.text);
-            }
-          });
-          return result;
-        }
-        return element.value;
+    } else if (isDefined(value)) {
+      // setter
+
+      if (value === null || (value === false && isBooleanAttr)) {
+        element.removeAttribute(name);
+      } else {
+        element.setAttribute(name, isBooleanAttr ? lowercasedName : value);
       }
-      element.value = value;
-    },
-  },
-  (fn, name) => {
-    /**
-     * Properties: writes return selection, reads return first value
-     */
-    JQLite.prototype[name] = function (arg1, arg2) {
-      let i;
-      let key;
-      const nodeCount = this.length;
-
-      // JQLiteEmpty takes no arguments but is a setter.
-      if (isUndefined(fn.length === 2 && fn !== getController ? arg1 : arg2)) {
-        if (isObject(arg1)) {
-          // we are a write, but the object properties are the key/values
-          for (i = 0; i < nodeCount; i++) {
-            if (fn === getOrSetCacheData) {
-              fn(this[i], arg1);
-            } else {
-              for (key in arg1) {
-                fn(this[i], key, arg1[key]);
-              }
-            }
-          }
-          // return self for chaining
-          return this;
-        }
-        // we are a read, so read the first child.
-        // TODO: do we still need this?
-        let value = fn.$dv;
-        // Only if we have $dv do we iterate over all, otherwise it is just the first element.
-        const jj = isUndefined(value) ? Math.min(nodeCount, 1) : nodeCount;
-        for (let j = 0; j < jj; j++) {
-          const nodeValue = fn(this[j], arg1, arg2);
-          value = value ? value + nodeValue : nodeValue;
-        }
-        return value;
+    } else {
+      // getter
+      ret = element.getAttribute(name);
+      if (isBooleanAttr && ret !== null) {
+        ret = lowercasedName;
       }
-      // we are a write, so apply to all children
+      // Normalize non-existing attributes to undefined (as jQuery).
+      return ret === null ? undefined : ret;
+    }
+  }
+
+  if (isDefined(value) || isObject(name)) {
+    return this;
+  }
+};
+
+/**
+ * @param {string|any} key - The key (as a string) to get/set or an object for mass-setting.
+ * @param {any} [value] - The value to set. If not provided, the function acts as a getter.
+ * @returns {JQLite|any} - The retrieved data if acting as a getter. Otherwise, returns undefined.
+ */
+JQLite.prototype.data = function (key, value) {
+  let i;
+  const nodeCount = this.length;
+  if (isUndefined(value)) {
+    if (isObject(key)) {
+      // we are a write, but the object properties are the key/values
       for (i = 0; i < nodeCount; i++) {
-        fn(this[i], arg1, arg2);
+        getOrSetCacheData(this[i], key);
       }
-      // return self for chaining
       return this;
-    };
-  },
-);
+    }
+    // we are a read, so read the first child.
+    const jj = isUndefined(value) ? Math.min(nodeCount, 1) : nodeCount;
+    for (let j = 0; j < jj; j++) {
+      const nodeValue = getOrSetCacheData(this[j], key, value);
+      value = value ? value + nodeValue : nodeValue;
+    }
+    return value;
+  }
+  // we are a write, so apply to all children
+  for (i = 0; i < nodeCount; i++) {
+    getOrSetCacheData(this[i], key, value);
+  }
+  return this;
+};
 
-/// ///////////////////////////////////////
-// Functions iterating traversal.
-// These functions chain results into a single
-// selector.
-/// ///////////////////////////////////////
-forEach(
-  {
-    replaceWith(element, replaceNode) {
-      let index;
-      const parent = element.parentNode;
-      dealoc(element);
-      forEach(new JQLite(replaceNode), (node) => {
-        if (index) {
-          parent.insertBefore(node, index.nextSibling);
-        } else {
-          parent.replaceChild(node, element);
-        }
-        index = node;
-      });
-    },
-    children(element) {
-      return Array.from(element.childNodes).filter(
-        (child) => child.nodeType === Node.ELEMENT_NODE,
-      );
-    },
-    append(element, node) {
-      const { nodeType } = element;
-      if (
-        nodeType !== Node.ELEMENT_NODE &&
-        nodeType !== Node.DOCUMENT_FRAGMENT_NODE
-      )
-        return;
+JQLite.prototype.replaceWith = function (arg1) {
+  let value;
+  let fn = function (element, replaceNode) {
+    let index;
+    const parent = element.parentNode;
+    dealoc(element);
+    forEach(new JQLite(replaceNode), (node) => {
+      if (index) {
+        parent.insertBefore(node, index.nextSibling);
+      } else {
+        parent.replaceChild(node, element);
+      }
+      index = node;
+    });
+  };
+  for (let i = 0; i < this.length; i++) {
+    if (isUndefined(value)) {
+      value = fn(this[i], arg1);
+      if (isDefined(value)) {
+        // any function which returns a value needs to be wrapped
+        value = JQLite(value);
+      }
+    } else {
+      addNodes(value, fn(this[i], arg1));
+    }
+  }
+  return isDefined(value) ? value : this;
+};
 
-      node = new JQLite(node);
+JQLite.prototype.children = function () {
+  let value;
+  let fn = (element) =>
+    Array.from(element.childNodes).filter(
+      (child) => child.nodeType === Node.ELEMENT_NODE,
+    );
+  for (let i = 0; i < this.length; i++) {
+    value = JQLite(fn(this[i]));
+  }
+  return isDefined(value) ? value : this;
+};
 
-      for (let i = 0, ii = node.length; i < ii; i++) {
-        const child = node[i];
-        element.appendChild(child);
-      }
-    },
+/**
+ * @param {string} node
+ * @returns {JQLite}
+ */
+JQLite.prototype.append = function (node) {
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    const { nodeType } = element;
+    if (
+      nodeType !== Node.ELEMENT_NODE &&
+      nodeType !== Node.DOCUMENT_FRAGMENT_NODE
+    )
+      return this;
 
-    prepend(element, node) {
-      if (element.nodeType === Node.ELEMENT_NODE) {
-        const index = element.firstChild;
-        forEach(new JQLite(node), (child) => {
-          element.insertBefore(child, index);
-        });
-      }
-    },
+    let newNode = new JQLite(node);
 
-    remove: removeElement,
+    for (let i = 0; i < newNode.length; i++) {
+      const child = newNode[i];
+      element.appendChild(child);
+    }
+  }
+  return this;
+};
 
-    detach(element) {
-      removeElement(element, true);
-    },
+/**
+ * @param {string} node
+ * @returns {JQLite}
+ */
+JQLite.prototype.prepend = function (node) {
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    if (element.nodeType === Node.ELEMENT_NODE) {
+      const index = element.firstChild;
+      forEach(new JQLite(node), (child) => {
+        element.insertBefore(child, index);
+      });
+    }
+  }
+  return this;
+};
 
-    after(element, newElement) {
-      let index = element;
-      const parent = element.parentNode;
+/**
+ * @param {string} newElement
+ * @returns {JQLite}
+ */
+JQLite.prototype.after = function (newElement) {
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    let index = element;
+    const parent = element.parentNode;
 
-      if (parent) {
-        newElement = new JQLite(newElement);
+    if (parent) {
+      let el = new JQLite(newElement);
 
-        for (let i = 0, ii = newElement.length; i < ii; i++) {
-          const node = newElement[i];
-          parent.insertBefore(node, index.nextSibling);
-          index = node;
-        }
+      for (let i = 0, ii = el.length; i < ii; i++) {
+        const node = el[i];
+        parent.insertBefore(node, index.nextSibling);
+        index = node;
+      }
+    }
+  }
+  return this;
+};
+
+/**
+ * @param {boolean} [keepData]
+ * @returns
+ */
+JQLite.prototype.remove = function (keepData = false) {
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    removeElement(element, keepData);
+  }
+  return this;
+};
+
+JQLite.prototype.detach = function () {
+  for (let i = 0; i < this.length; i++) {
+    const element = this[i];
+    removeElement(element, true);
+  }
+  return this;
+};
+
+JQLite.prototype.parent = function () {
+  let value;
+  let fn = (element) => {
+    const parent = element.parentNode;
+    return parent && parent.nodeType !== Node.DOCUMENT_FRAGMENT_NODE
+      ? parent
+      : null;
+  };
+  for (let i = 0, ii = this.length; i < ii; i++) {
+    if (isUndefined(value)) {
+      value = fn(this[i]);
+      if (isDefined(value)) {
+        value = JQLite(value);
       }
-    },
+    } else {
+      addNodes(value, fn(this[i]));
+    }
+  }
+  return isDefined(value) ? value : this;
+};
 
-    parent(element) {
-      const parent = element.parentNode;
-      return parent && parent.nodeType !== Node.DOCUMENT_FRAGMENT_NODE
-        ? parent
-        : null;
-    },
+JQLite.prototype.find = function (selector) {
+  let value;
+  for (let i = 0, ii = this.length; i < ii; i++) {
+    const element = this[i];
 
-    // TODO: remove after migrating tests away from JQLite
-    find(element, selector) {
+    if (isUndefined(value)) {
       if (element.getElementsByTagName) {
-        return element.getElementsByTagName(selector);
+        value = element.getElementsByTagName(selector);
+      } else {
+        value = [];
       }
-      return [];
-    },
-
-    triggerHandler(element, event, extraParameters) {
-      let dummyEvent;
-      let eventFnsCopy;
-      let handlerArgs;
-      const eventName = event.type || event;
-      const expandoStore = getExpando(element);
-      const events = expandoStore && expandoStore.events;
-      const eventFns = events && events[eventName];
-
-      if (eventFns) {
-        // Create a dummy event to pass to the handlers
-        dummyEvent = {
-          preventDefault() {
-            this.defaultPrevented = true;
-          },
-          isDefaultPrevented() {
-            return this.defaultPrevented === true;
-          },
-          stopImmediatePropagation() {
-            this.immediatePropagationStopped = true;
-          },
-          isImmediatePropagationStopped() {
-            return this.immediatePropagationStopped === true;
-          },
-          stopPropagation: () => {},
-          type: eventName,
-          target: element,
-        };
-
-        // If a custom event was provided then extend our dummy event with it
-        if (event.type) {
-          dummyEvent = extend(dummyEvent, event);
-        }
+      if (isDefined(value)) {
+        // any function which returns a value needs to be wrapped
+        value = JQLite(value);
+      }
+    } else {
+      if (element.getElementsByTagName) {
+        addNodes(value, element.getElementsByTagName(selector));
+      }
+    }
+  }
+  return isDefined(value) ? value : this;
+};
 
-        // Copy event handlers in case event handlers array is modified during execution.
-        eventFnsCopy = shallowCopy(eventFns);
-        handlerArgs = extraParameters
-          ? [dummyEvent].concat(extraParameters)
-          : [dummyEvent];
+/**
+ * TODO: REMOVE! This function being used ONLY in tests!
+ */
+JQLite.prototype.triggerHandler = function (event, extraParameters) {
+  let value;
+  let fn = function (element, event, extraParameters) {
+    let dummyEvent;
+    let eventFnsCopy;
+    let handlerArgs;
+    const eventName = event.type || event;
+    const expandoStore = getExpando(element);
+    const events = expandoStore && expandoStore.events;
+    const eventFns = events && events[eventName];
+
+    if (eventFns) {
+      // Create a dummy event to pass to the handlers
+      dummyEvent = {
+        preventDefault() {
+          this.defaultPrevented = true;
+        },
+        isDefaultPrevented() {
+          return this.defaultPrevented === true;
+        },
+        stopImmediatePropagation() {
+          this.immediatePropagationStopped = true;
+        },
+        isImmediatePropagationStopped() {
+          return this.immediatePropagationStopped === true;
+        },
+        stopPropagation: () => {},
+        type: eventName,
+        target: element,
+      };
 
-        forEach(eventFnsCopy, (fn) => {
-          if (!dummyEvent.isImmediatePropagationStopped()) {
-            fn.apply(element, handlerArgs);
-          }
-        });
+      // If a custom event was provided then extend our dummy event with it
+      if (event.type) {
+        dummyEvent = extend(dummyEvent, event);
       }
-    },
-  },
-  (fn, name) => {
-    /**
-     * chaining functions
-     */
-    JQLite.prototype[name] = function (arg1, arg2, arg3) {
-      let value;
-
-      for (let i = 0, ii = this.length; i < ii; i++) {
-        if (isUndefined(value)) {
-          value = fn(this[i], arg1, arg2, arg3);
-          if (isDefined(value)) {
-            // any function which returns a value needs to be wrapped
-            value = JQLite(value);
-          }
-        } else {
-          addNodes(value, fn(this[i], arg1, arg2, arg3));
+
+      // Copy event handlers in case event handlers array is modified during execution.
+      eventFnsCopy = shallowCopy(eventFns);
+      handlerArgs = extraParameters
+        ? [dummyEvent].concat(extraParameters)
+        : [dummyEvent];
+
+      forEach(eventFnsCopy, (fn) => {
+        if (!dummyEvent.isImmediatePropagationStopped()) {
+          fn.apply(element, handlerArgs);
         }
+      });
+    }
+  };
+  for (let i = 0, ii = this.length; i < ii; i++) {
+    if (isUndefined(value)) {
+      value = fn(this[i], event, extraParameters);
+      if (isDefined(value)) {
+        // @ts-ignore
+        value = JQLite(value);
       }
-      return isDefined(value) ? value : this;
-    };
-  },
-);
+    } else {
+      // @ts-ignore
+      addNodes(value, fn(this[i], event, extraParameters));
+    }
+  }
+  return isDefined(value) ? value : this;
+};
 
 ///////////////////////////////////////////////////////////////////
 ////////////        HELPER FUNCTIONS      /////////////////////////
@@ -955,7 +1055,7 @@ function getController(element, name) {
 /**
  *
  * @param {Element} element
- * @param {string} name
+ * @param {string|string[]} name
  * @param {any} [value]
  * @returns
  */
@@ -1136,13 +1236,13 @@ export function getBooleanAttrName(element, name) {
   const booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
 
   // booleanAttr is here twice to minimize DOM access
-  return booleanAttr && BOOLEAN_ELEMENTS[nodeName_(element)] && booleanAttr;
+  return booleanAttr && BOOLEAN_ELEMENTS[getNodeName(element)] && booleanAttr;
 }
 
 /**
  * Takes an array of elements, calls any `$destroy` event handlers, removes any data in cache, and finally removes any
  * listeners.
- * @param {NodeListOf<Element>} nodes
+ * @param {NodeListOf<Element>|Element[]} nodes
  */
 export function cleanElementData(nodes) {
   for (let i = 0, ii = nodes.length; i < ii; i++) {