@angular-wave/angular.ts 0.0.46 → 0.0.48

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/src/shared/utils.js

@@ -309,7 +309,6 @@ export function trim(value) {
   return isString(value) ? value.trim() : value;
 }
 
-// eslint-disable-next-line camelcase
 export function snakeCase(name, separator) {
   const modseparator = separator || "_";
   return name.replace(
@@ -399,7 +398,7 @@ export function forEachSorted(obj, iterator, context) {
 
 /**
  * when using forEach the params are value, key, but it is often useful to have key, value.
- * @param {function(string, *)} iteratorFn
+ * @param {function(string, *):any} iteratorFn
  * @returns {function(*, string)}
  */
 export function reverseParams(iteratorFn) {
@@ -473,8 +472,8 @@ export function baseExtend(dst, objs, deep) {
  * @param {...Object} src Source object(s).
  * @returns {Object} Reference to `dst`.
  */
-export function extend(dst) {
-  return baseExtend(dst, [].slice.call(arguments, 1), false);
+export function extend(dst, ...src) {
+  return baseExtend(dst, src, false);
 }
 
 /**
@@ -515,15 +514,27 @@ export function merge(dst, ...src) {
   return baseExtend(dst, src, true);
 }
 
+/**
+ * @param {string} str
+ * @returns {number}
+ */
 export function toInt(str) {
   return parseInt(str, 10);
 }
 
+/**
+ * @param {any} num
+ * @returns {boolean}
+ */
 export function isNumberNaN(num) {
-  // eslint-disable-next-line no-self-compare
   return Number.isNaN(num);
 }
 
+/**
+ * @param {Object} parent
+ * @param {Object} extra
+ * @returns {Object}
+ */
 export function inherit(parent, extra) {
   return extend(Object.create(parent), extra);
 }
@@ -599,7 +610,7 @@ export function isElement(node) {
  *
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/nodeName)
  *
- * @param {JQLite|Element} element
+ * @param {import('../shared/jqlite/jqlite').JQLite|Element} element
  * @returns
  */
 export function getNodeName(element) {
@@ -699,7 +710,7 @@ export function simpleCompare(a, b) {
 export function equals(o1, o2) {
   if (o1 === o2) return true;
   if (o1 === null || o2 === null) return false;
-  // eslint-disable-next-line no-self-compare
+
   if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
   const t1 = typeof o1;
   const t2 = typeof o2;

package/src/types.js

@@ -11,6 +11,16 @@
  * @template T
  */
 
+/**
+ * @typedef {function(any, any=): any} CompiledExpression
+ * @property {boolean} literal - Indicates if the expression is a literal.
+ * @property {boolean} constant - Indicates if the expression is constant.
+ * @property {function(any, any): any} assign - Assigns a value to a context. If value is not provided,
+ * undefined is gonna be used since the implementation
+ * does not check the parameter. Let's force a value for consistency. If consumer
+ * wants to undefine it, pass the undefined value explicitly.
+ */
+
 /**
  * @typedef {Object} ComponentOptions
  * @description Component definition object (a simplified directive definition object)

package/types/core/parser/ast-type.d.ts

@@ -0,0 +1,20 @@
+export type ASTType = ("Program" | "ExpressionStatement" | "AssignmentExpression" | "ConditionalExpression" | "LogicalExpression" | "BinaryExpression" | "UnaryExpression" | "CallExpression" | "MemberExpression" | "Identifier" | "Literal" | "ArrayExpression" | "Property" | "ObjectExpression" | "ThisExpression" | "LocalsExpression" | "NGValueParameter");
+export namespace ASTType {
+    let Program: string;
+    let ExpressionStatement: string;
+    let AssignmentExpression: string;
+    let ConditionalExpression: string;
+    let LogicalExpression: string;
+    let BinaryExpression: string;
+    let UnaryExpression: string;
+    let CallExpression: string;
+    let MemberExpression: string;
+    let Identifier: string;
+    let Literal: string;
+    let ArrayExpression: string;
+    let Property: string;
+    let ObjectExpression: string;
+    let ThisExpression: string;
+    let LocalsExpression: string;
+    let NGValueParameter: string;
+}

package/types/core/parser/ast.d.ts

@@ -0,0 +1,78 @@
+export function AST(lexer: any, options: any): void;
+export class AST {
+    constructor(lexer: any, options: any);
+    lexer: any;
+    options: any;
+    ast(text: any): {
+        type: string;
+        body: {
+            type: string;
+            expression: any;
+        }[];
+    };
+    text: any;
+    tokens: any;
+    program(): {
+        type: string;
+        body: {
+            type: string;
+            expression: any;
+        }[];
+    };
+    expressionStatement(): {
+        type: string;
+        expression: any;
+    };
+    filterChain(): any;
+    expression(): any;
+    assignment(): any;
+    ternary(): any;
+    logicalOR(): any;
+    logicalAND(): any;
+    equality(): any;
+    relational(): any;
+    additive(): any;
+    multiplicative(): any;
+    unary(): any;
+    primary(): any;
+    filter(baseExpression: any): {
+        type: string;
+        callee: {
+            type: string;
+            name: any;
+        };
+        arguments: any[];
+        filter: boolean;
+    };
+    parseArguments(): any;
+    identifier(): {
+        type: string;
+        name: any;
+    };
+    constant(): {
+        type: string;
+        value: any;
+    };
+    arrayDeclaration(): any;
+    object(): {
+        type: string;
+        properties: {
+            type: string;
+            kind: string;
+        }[];
+    };
+    throwError(msg: any, token: any): never;
+    consume(e1: any): any;
+    peekToken(): any;
+    peek(e1: any, e2: any, e3: any, e4: any): any;
+    peekAhead(i: any, e1: any, e2: any, e3: any, e4: any): any;
+    expect(e1: any, e2: any, e3: any, e4: any): any;
+    selfReferential: {
+        this: {
+            type: string;
+        };
+        $locals: {
+            type: string;
+        };
+    };
+}

package/types/core/parser/compiler.d.ts

@@ -0,0 +1,49 @@
+export function ASTCompiler($filter: any): void;
+export class ASTCompiler {
+    constructor($filter: any);
+    $filter: any;
+    compile(ast: any): any;
+    state: {
+        nextId: number;
+        filters: {};
+        fn: {
+            vars: any[];
+            body: any[];
+            own: {};
+        };
+        assign: {
+            vars: any[];
+            body: any[];
+            own: {};
+        };
+        inputs: any[];
+    };
+    stage: string;
+    watchFns(): string;
+    generateFunction(name: any, params: any): string;
+    filterPrefix(): string;
+    varsPrefix(section: any): string;
+    body(section: any): any;
+    recurse(ast: any, intoId: any, nameId: any, recursionFn: any, create: any, skipWatchIdCheck: any): void;
+    getHasOwnProperty(element: any, property: any): any;
+    assign(id: any, value: any): any;
+    filter(filterName: any): any;
+    ifDefined(id: any, defaultValue: any): string;
+    plus(left: any, right: any): string;
+    return_(id: any): void;
+    if_(test: any, alternate: any, consequent: any): void;
+    not(expression: any): string;
+    isNull(expression: any): string;
+    notNull(expression: any): string;
+    nonComputedMember(left: any, right: any): string;
+    computedMember(left: any, right: any): string;
+    member(left: any, right: any, computed: any): string;
+    getStringValue(item: any): void;
+    lazyRecurse(ast: any, intoId: any, nameId: any, recursionFn: any, create: any, skipWatchIdCheck: any): () => void;
+    lazyAssign(id: any, value: any): () => void;
+    stringEscapeRegex: RegExp;
+    stringEscapeFn(c: any): string;
+    escape(value: any): any;
+    nextId(skip: any, init: any): string;
+    current(): any;
+}