@angular-wave/angular.ts 0.0.46 → 0.0.47

package/src/shared/jqlite/jqlite.js

@@ -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) {
@@ -538,162 +537,242 @@ JQLite.prototype.data = function (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      /////////////////////////

package/types/directive/attrs/attrs.d.ts

@@ -1,176 +1,2 @@
-/**
- * @ngdoc directive
- * @name ngHref
- * @restrict A
- * @priority 99
- *
- * @description
- * Using AngularJS markup like `{{hash}}` in an href attribute will
- * make the link go to the wrong URL if the user clicks it before
- * AngularJS has a chance to replace the `{{hash}}` markup with its
- * value. Until AngularJS replaces the markup the link will be broken
- * and will most likely return a 404 error. The `ngHref` directive
- * solves this problem.
- *
- * The wrong way to write it:
- * ```html
- * <a href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
- * ```
- *
- * The correct way to write it:
- * ```html
- * <a ng-href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
- * ```
- *
- * @element A
- * @param {template} ngHref any string which can contain `{{}}` markup.
- *
- */
 export const REGEX_STRING_REGEXP: RegExp;
-/**
- * @ngdoc directive
- * @name ngSrc
- * @restrict A
- * @priority 99
- *
- * @description
- * Using AngularJS markup like `{{hash}}` in a `src` attribute doesn't
- * work right: The browser will fetch from the URL with the literal
- * text `{{hash}}` until AngularJS replaces the expression inside
- * `{{hash}}`. The `ngSrc` directive solves this problem.
- *
- * The buggy way to write it:
- * ```html
- * <img src="http://www.gravatar.com/avatar/{{hash}}" alt="Description"/>
- * ```
- *
- * The correct way to write it:
- * ```html
- * <img ng-src="http://www.gravatar.com/avatar/{{hash}}" alt="Description" />
- * ```
- *
- * @element IMG
- * @param {template} ngSrc any string which can contain `{{}}` markup.
- */
-/**
- * @ngdoc directive
- * @name ngSrcset
- * @restrict A
- * @priority 99
- *
- * @description
- * Using AngularJS markup like `{{hash}}` in a `srcset` attribute doesn't
- * work right: The browser will fetch from the URL with the literal
- * text `{{hash}}` until AngularJS replaces the expression inside
- * `{{hash}}`. The `ngSrcset` directive solves this problem.
- *
- * The buggy way to write it:
- * ```html
- * <img srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description"/>
- * ```
- *
- * The correct way to write it:
- * ```html
- * <img ng-srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description" />
- * ```
- *
- * @element IMG
- * @param {template} ngSrcset any string which can contain `{{}}` markup.
- */
-/**
- * @ngdoc directive
- * @name ngDisabled
- * @restrict A
- * @priority 100
- *
- * @description
- *
- * This directive sets the `disabled` attribute on the element (typically a form control,
- * e.g. `input`, `button`, `select` etc.) if the
- * {@link guide/expression expression} inside `ngDisabled` evaluates to truthy.
- *
- * A special directive is necessary because we cannot use interpolation inside the `disabled`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- *
- * @param {string} ngDisabled If the {@link guide/expression expression} is truthy,
- *     then the `disabled` attribute will be set on the element
- */
-/**
- * @ngdoc directive
- * @name ngChecked
- * @restrict A
- * @priority 100
- *
- * @description
- * Sets the `checked` attribute on the element, if the expression inside `ngChecked` is truthy.
- *
- * Note that this directive should not be used together with {@link ngModel `ngModel`},
- * as this can lead to unexpected behavior.
- *
- * A special directive is necessary because we cannot use interpolation inside the `checked`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- *
- * @element INPUT
- * @param {string} ngChecked If the {@link guide/expression expression} is truthy,
- *     then the `checked` attribute will be set on the element
- */
-/**
- *
- * @description
- *
- * Sets the `readonly` attribute on the element, if the expression inside `ngReadonly` is truthy.
- * Note that `readonly` applies only to `input` elements with specific types. [See the input docs on
- * MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-readonly) for more information.
- *
- * A special directive is necessary because we cannot use interpolation inside the `readonly`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- * @element INPUT
- * @param {string} ngReadonly If the {@link guide/expression expression} is truthy,
- *     then special attribute "readonly" will be set on the element
- */
-/**
- * @ngdoc directive
- * @name ngSelected
- * @restrict A
- * @priority 100
- *
- * @description
- *
- * Sets the `selected` attribute on the element, if the expression inside `ngSelected` is truthy.
- *
- * A special directive is necessary because we cannot use interpolation inside the `selected`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- *
- * <div class="alert alert-warning">
- *   **Note:** `ngSelected` does not interact with the `select` and `ngModel` directives, it only
- *   sets the `selected` attribute on the element. If you are using `ngModel` on the select, you
- *   should not use `ngSelected` on the options, as `ngModel` will set the select value and
- *   selected options.
- * </div>
- * @element OPTION
- * @param {string} ngSelected If the {@link guide/expression expression} is truthy,
- *     then special attribute "selected" will be set on the element
- */
-/**
- * @ngdoc directive
- * @name ngOpen
- * @restrict A
- * @priority 100
- *
- * @description
- *
- * Sets the `open` attribute on the element, if the expression inside `ngOpen` is truthy.
- *
- * A special directive is necessary because we cannot use interpolation inside the `open`
- * attribute. See the {@link guide/interpolation interpolation guide} for more info.
- *
- * ## A note about browser compatibility
- *
- * Internet Explorer and Edge do not support the `details` element, it is
- * recommended to use {@link ng.ngShow} and {@link ng.ngHide} instead.
- *
- * @element DETAILS
- * @param {string} ngOpen If the {@link guide/expression expression} is truthy,
- *     then special attribute "open" will be set on the element
- */
 export const ngAttributeAliasDirectives: {};

package/types/shared/jqlite/jqlite.d.ts

@@ -2,19 +2,19 @@
  * 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: string | Element | Document | Window | JQLite | ArrayLike<Element> | (() => void)): JQLite;
+export function JQLite(element: string | Element | Comment | Document | Window | JQLite | ArrayLike<Element> | (() => void)): JQLite;
 export class JQLite {
     /**
      * 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}
      */
-    constructor(element: string | Element | Document | Window | JQLite | ArrayLike<Element> | (() => void));
+    constructor(element: string | Element | Comment | Document | Window | JQLite | ArrayLike<Element> | (() => void));
     /**
      * Remove all child nodes of the set of matched elements from the DOM and clears CACHE data, associated with the node.
      * @returns {JQLite} The current instance of JQLite.
@@ -101,6 +101,35 @@ export class JQLite {
      * @returns {JQLite|any} - The retrieved data if acting as a getter. Otherwise, returns undefined.
      */
     data(key: string | any, value?: any): JQLite | any;
+    replaceWith(arg1: any): void | JQLite;
+    children(): JQLite;
+    /**
+     * @param {string} node
+     * @returns {JQLite}
+     */
+    append(node: string): JQLite;
+    /**
+     * @param {string} node
+     * @returns {JQLite}
+     */
+    prepend(node: string): JQLite;
+    /**
+     * @param {string} newElement
+     * @returns {JQLite}
+     */
+    after(newElement: string): JQLite;
+    /**
+     * @param {boolean} [keepData]
+     * @returns
+     */
+    remove(keepData?: boolean): this;
+    detach(): this;
+    parent(): any;
+    find(selector: any): any;
+    /**
+     * TODO: REMOVE! This function being used ONLY in tests!
+     */
+    triggerHandler(event: any, extraParameters: any): void | JQLite;
     toString(): string;
     eq(index: any): JQLite;
     length: number;