@angular-wave/angular.ts 0.0.72 → 0.1.0

package/src/core/compile/compile.spec.js

@@ -17149,7 +17149,6 @@ describe("$compile", () => {
       $rootScope.$digest();
       await wait(100);
       const spans = element.find("span");
-      debugger;
       expect(spans.eq(0)[0].classList.contains("ng-hide")).toBeTrue();
       //expect(spans.eq(1)[0].classList.contains("ng-hide")).toBeTrue();
       expect(spans.eq(2)[0].classList.contains("ng-hide")).toBeTrue();

package/src/core/controller/controller.js

@@ -162,7 +162,9 @@ export function $ControllerProvider() {
               locals,
               identifier,
               instance,
-              constructor || expression.name,
+              constructor ||
+                /** @type {import("../../types").Controller} */ (expression)
+                  .name,
             );
           }
 
@@ -185,7 +187,10 @@ export function $ControllerProvider() {
                     locals,
                     identifier,
                     instance,
-                    constructor || expression.name,
+                    constructor ||
+                      /** @type {import("../../types").Controller} */ (
+                        expression
+                      ).name,
                   );
                 }
               }
@@ -209,7 +214,8 @@ export function $ControllerProvider() {
             locals,
             identifier,
             instance,
-            constructor || expression.name,
+            constructor ||
+              /** @type {import("../../types").Controller} */ (expression).name,
           );
         }
 

package/src/core/interpolate/interpolate.js

@@ -9,7 +9,7 @@ import {
 import { constantWatchDelegate } from "../parser/parse";
 
 const $interpolateMinErr = minErr("$interpolate");
-$interpolateMinErr.throwNoconcat = function (text) {
+function throwNoconcat(text) {
   throw $interpolateMinErr(
     "noconcat",
     "Error while interpolating: {0}\nStrict Contextual Escaping disallows " +
@@ -17,16 +17,16 @@ $interpolateMinErr.throwNoconcat = function (text) {
       "required.  See http://docs.angularjs.org/api/ng.$sce",
     text,
   );
-};
+}
 
-$interpolateMinErr.interr = function (text, err) {
+function interr(text, err) {
   throw $interpolateMinErr(
     "interr",
     "Can't interpolate: {0}\n{1}",
     text,
     err.toString(),
   );
-};
+}
 
 /**
  *
@@ -48,7 +48,7 @@ export function $InterpolateProvider() {
    * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
    *
    * @param {string=} value new value to set the starting symbol to.
-   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+   * @returns {string|$InterpolateProvider} Returns the symbol when used as getter and self if used as setter.
    */
   this.startSymbol = function (value) {
     if (value) {
@@ -62,7 +62,7 @@ export function $InterpolateProvider() {
    * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
    *
    * @param {string=} value new value to set the ending symbol to.
-   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+   * @returns {string|$InterpolateProvider} Returns the symbol when used as getter and self if used as setter.
    */
   this.endSymbol = function (value) {
     if (value) {
@@ -215,7 +215,7 @@ export function $InterpolateProvider() {
        *    provides Strict Contextual Escaping for details.
        * @param {boolean=} allOrNothing if `true`, then the returned function returns undefined
        *    unless all embedded expressions evaluate to a value other than `undefined`.
-       * @returns {function(context)} an interpolation function which is used to compute the
+       * @returns {Function} an interpolation function which is used to compute the
        *    interpolated string. The function has these parameters:
        *
        * - `context`: evaluation context for all expressions embedded in the interpolated text
@@ -237,6 +237,10 @@ export function $InterpolateProvider() {
           if (contextAllowsConcatenation) {
             unescapedText = $sce.getTrusted(trustedContext, unescapedText);
           }
+
+          /**
+           * @type {any}
+           */
           const constantInterp = valueFn(unescapedText);
           constantInterp.exp = text;
           constantInterp.expressions = [];
@@ -322,7 +326,7 @@ export function $InterpolateProvider() {
             }
             if (trustedContext && concat.length > 1) {
               // This context does not allow more than one part, e.g. expr + string or exp + exp.
-              $interpolateMinErr.throwNoconcat(text);
+              throwNoconcat(text);
             }
             // In an unprivileged context or only one part: just concatenate and return.
             return concat.join("");
@@ -341,7 +345,7 @@ export function $InterpolateProvider() {
 
                 return compute(values);
               } catch (err) {
-                $exceptionHandler($interpolateMinErr.interr(text, err));
+                interr(text, err);
               }
             },
             {
@@ -380,7 +384,7 @@ export function $InterpolateProvider() {
                 : $sce.valueOf(value);
             return allOrNothing && !isDefined(value) ? value : stringify(value);
           } catch (err) {
-            $exceptionHandler($interpolateMinErr.interr(text, err));
+            interr(text, err);
           }
         }
       }

package/src/core/q/q.js

@@ -16,7 +16,7 @@ import {
  * @property {function(
  *   ((value: T) => (PromiseLike<never>|PromiseLike<T>|T))|null,
  *   ((reason: any) => (PromiseLike<never>|PromiseLike<T>|T))|null,
- *   ((state: any) => any)
+ *   ((state: any) => any)=
  * ): QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
  * @property {function(
  *   ((value: T) => (QPromise<never>|QPromise<T>|T))|null,
@@ -25,6 +25,7 @@ import {
  * ): QPromise<T|never>} then - Calls one of the success or error callbacks asynchronously as soon as the result is available.
  * @property {function(((reason: any) => (PromiseLike<never>|PromiseLike<T>|T))|null): QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
  * @property {function(((reason: any) => (QPromise<never>|QPromise<T>|T))|null): QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
+ * @property {function(Array.<QPromise<T>>): QPromise<T>} all
  * @property {function(function(): void): QPromise<T>} finally - Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value.
  * @property {number} [$$intervalId] - Internal id set by the $interval service for callback notifications
  * @property {number} [$$timeoutId] - Timeout id set by the $timeout service for cancelations

package/src/directive/change/change.js

@@ -6,7 +6,9 @@ export function ngChangeDirective() {
     restrict: "A",
     require: "ngModel",
     link(scope, _element, attr, ctrl) {
-      ctrl.$viewChangeListeners.push(() => scope.$eval(attr.ngChange));
+      /** @type {import('../../types').NgModelController} */ (
+        ctrl
+      ).$viewChangeListeners.push(() => scope.$eval(attr.ngChange));
     },
   };
 }

package/src/directive/form/form.js

@@ -21,13 +21,14 @@ export const nullFormCtrl = {
   $getControls: valueFn([]),
   $$renameControl: nullFormRenameControl,
   $removeControl: () => {},
-  $setValidity: () => {},
+  /** @type {(...any) => any} */
+  $setValidity: function () {},
   $setDirty: () => {},
   $setPristine: () => {},
   $setSubmitted: () => {},
   $$setSubmitted: () => {},
 };
-const PENDING_CLASS = "ng-pending";
+export const PENDING_CLASS = "ng-pending";
 const SUBMITTED_CLASS = "ng-submitted";
 
 function nullFormRenameControl(control, name) {
@@ -695,7 +696,7 @@ export function addSetValidityMethod(context) {
   }
 }
 
-function isObjectEmpty(obj) {
+export function isObjectEmpty(obj) {
   if (obj) {
     for (const prop in obj) {
       if (Object.prototype.hasOwnProperty.call(obj, prop)) {

package/src/directive/list/list.js

@@ -28,8 +28,8 @@ export function ngListDirective() {
         return list;
       };
 
-      ctrl.$parsers.push(parse);
-      ctrl.$formatters.push((value) => {
+      ctrl["$parsers"].push(parse);
+      ctrl["$formatters"].push((value) => {
         if (Array.isArray(value)) {
           return value.join(ngList);
         }
@@ -38,7 +38,7 @@ export function ngListDirective() {
       });
 
       // Override the standard $isEmpty because an empty array means the input is empty.
-      ctrl.$isEmpty = function (value) {
+      ctrl["$isEmpty"] = function (value) {
         return !value || !value.length;
       };
     },

package/src/directive/messages/messages.js

@@ -1,198 +1,203 @@
-import { forEach, isString } from "../../shared/utils";
-
-ngMessagesDirective.$inject = ["$animate"];
-export function ngMessagesDirective($animate) {
-  const ACTIVE_CLASS = "ng-active";
-  const INACTIVE_CLASS = "ng-inactive";
-  return {
-    require: "ngMessages",
-    restrict: "AE",
-    controller: function ($element, $scope, $attrs) {
-      const ctrl = this;
-      let latestKey = 0;
-      let nextAttachId = 0;
-      const messages = {};
-      let renderLater;
-      let cachedCollection;
-
-      this.head = undefined;
-      this.default = undefined;
-      this.messages = messages;
-
-      this.getAttachId = function getAttachId() {
-        return nextAttachId++;
-      };
+import { isString } from "../../shared/utils";
+
+const ACTIVE_CLASS = "ng-active";
+const INACTIVE_CLASS = "ng-inactive";
+
+class NgMessageCtrl {
+  /**
+   * @param {import('../../shared/jqlite/jqlite').JQLite} $element
+   * @param {import('../../core/scope/scope').Scope} $scope
+   * @param {import('../../core/compile/attributes').Attributes} $attrs
+   * @param {*} $animate
+   */
+  constructor($element, $scope, $attrs, $animate) {
+    this.$element = $element;
+    this.$scope = $scope;
+    this.$attrs = $attrs;
+    this.$animate = $animate;
+
+    this.latestKey = 0;
+    this.nextAttachId = 0;
+    this.messages = {};
+    this.renderLater = false;
+    this.cachedCollection = null;
+
+    this.head = undefined;
+    this.default = undefined;
+
+    this.$scope.$watchCollection(
+      this.$attrs["ngMessages"] || this.$attrs["for"],
+      this.render.bind(this),
+    );
+  }
 
-      this.render = function (collection) {
-        collection = collection || {};
-
-        renderLater = false;
-        cachedCollection = collection;
-
-        // this is true if the attribute is empty or if the attribute value is truthy
-        const multiple =
-          isAttrTruthy($scope, $attrs.ngMessagesMultiple) ||
-          isAttrTruthy($scope, $attrs.multiple);
-
-        const unmatchedMessages = [];
-        const matchedKeys = {};
-        let truthyKeys = 0;
-        let messageItem = ctrl.head;
-        let messageFound = false;
-        let totalMessages = 0;
-
-        // we use != instead of !== to allow for both undefined and null values
-        while (messageItem != null) {
-          totalMessages++;
-          const messageCtrl = messageItem.message;
-
-          let messageUsed = false;
-          if (!messageFound) {
-            forEach(collection, (value, key) => {
-              if (truthy(value) && !messageUsed) {
-                truthyKeys++;
-
-                if (messageCtrl.test(key)) {
-                  // this is to prevent the same error name from showing up twice
-                  if (matchedKeys[key]) return;
-                  matchedKeys[key] = true;
-
-                  messageUsed = true;
-                  messageCtrl.attach();
-                }
-              }
-            });
-          }
+  getAttachId() {
+    return this.nextAttachId++;
+  }
 
-          if (messageUsed) {
-            // unless we want to display multiple messages then we should
-            // set a flag here to avoid displaying the next message in the list
-            messageFound = !multiple;
-          } else {
-            unmatchedMessages.push(messageCtrl);
+  render(collection = {}) {
+    this.renderLater = false;
+    this.cachedCollection = collection;
+
+    const multiple =
+      isAttrTruthy(this.$scope, this.$attrs["ngMessagesMultiple"]) ||
+      isAttrTruthy(this.$scope, this.$attrs["multiple"]);
+
+    const unmatchedMessages = [];
+    const matchedKeys = {};
+    let truthyKeys = 0;
+    let messageItem = this.head;
+    let messageFound = false;
+    let totalMessages = 0;
+
+    while (messageItem != null) {
+      totalMessages++;
+      const messageCtrl = messageItem.message;
+      let messageUsed = false;
+
+      if (!messageFound) {
+        Object.entries(collection).forEach(([key, value]) => {
+          if (truthy(value) && !messageUsed) {
+            truthyKeys++;
+
+            if (messageCtrl.test(key)) {
+              if (matchedKeys[key]) return;
+              matchedKeys[key] = true;
+
+              messageUsed = true;
+              messageCtrl.attach();
+            }
           }
-
-          messageItem = messageItem.next;
-        }
-
-        forEach(unmatchedMessages, (messageCtrl) => {
-          messageCtrl.detach();
         });
+      }
 
-        const messageMatched = unmatchedMessages.length !== totalMessages;
-        const attachDefault = ctrl.default && !messageMatched && truthyKeys > 0;
+      if (messageUsed) {
+        messageFound = !multiple;
+      } else {
+        unmatchedMessages.push(messageCtrl);
+      }
 
-        if (attachDefault) {
-          ctrl.default.attach();
-        } else if (ctrl.default) {
-          ctrl.default.detach();
-        }
+      messageItem = messageItem.next;
+    }
 
-        if (messageMatched || attachDefault) {
-          $animate.setClass($element, ACTIVE_CLASS, INACTIVE_CLASS);
-        } else {
-          $animate.setClass($element, INACTIVE_CLASS, ACTIVE_CLASS);
-        }
-      };
+    unmatchedMessages.forEach((messageCtrl) => {
+      messageCtrl.detach();
+    });
 
-      $scope.$watchCollection($attrs.ngMessages || $attrs.for, ctrl.render);
+    const messageMatched = unmatchedMessages.length !== totalMessages;
+    const attachDefault = this.default && !messageMatched && truthyKeys > 0;
 
-      this.reRender = function () {
-        if (!renderLater) {
-          renderLater = true;
-          $scope.$evalAsync(() => {
-            if (renderLater && cachedCollection) {
-              ctrl.render(cachedCollection);
-            }
-          });
-        }
-      };
+    if (attachDefault) {
+      this.default.attach();
+    } else if (this.default) {
+      this.default.detach();
+    }
 
-      this.register = function (comment, messageCtrl, isDefault) {
-        if (isDefault) {
-          ctrl.default = messageCtrl;
-        } else {
-          const nextKey = latestKey.toString();
-          messages[nextKey] = {
-            message: messageCtrl,
-          };
-          insertMessageNode($element[0], comment, nextKey);
-          comment.$$ngMessageNode = nextKey;
-          latestKey++;
+    if (messageMatched || attachDefault) {
+      this.$animate.setClass(this.$element, ACTIVE_CLASS, INACTIVE_CLASS);
+    } else {
+      this.$animate.setClass(this.$element, INACTIVE_CLASS, ACTIVE_CLASS);
+    }
+  }
+
+  reRender() {
+    if (!this.renderLater) {
+      this.renderLater = true;
+      this.$scope.$evalAsync(() => {
+        if (this.renderLater && this.cachedCollection) {
+          this.render(this.cachedCollection);
         }
+      });
+    }
+  }
 
-        ctrl.reRender();
+  register(comment, messageCtrl, isDefault) {
+    if (isDefault) {
+      this.default = messageCtrl;
+    } else {
+      const nextKey = this.latestKey.toString();
+      this.messages[nextKey] = {
+        message: messageCtrl,
       };
+      this.insertMessageNode(this.$element[0], comment, nextKey);
+      comment.$$ngMessageNode = nextKey;
+      this.latestKey++;
+    }
 
-      this.deregister = function (comment, isDefault) {
-        if (isDefault) {
-          delete ctrl.default;
-        } else {
-          const key = comment.$$ngMessageNode;
-          delete comment.$$ngMessageNode;
-          removeMessageNode($element[0], comment, key);
-          delete messages[key];
-        }
-        ctrl.reRender();
-      };
+    this.reRender();
+  }
 
-      function findPreviousMessage(parent, comment) {
-        let prevNode = comment;
-        const parentLookup = [];
+  deregister(comment, isDefault) {
+    if (isDefault) {
+      delete this.default;
+    } else {
+      const key = comment.$$ngMessageNode;
+      delete comment.$$ngMessageNode;
+      this.removeMessageNode(this.$element[0], comment, key);
+      delete this.messages[key];
+    }
+    this.reRender();
+  }
 
-        while (prevNode && prevNode !== parent) {
-          const prevKey = prevNode.$$ngMessageNode;
-          if (prevKey && prevKey.length) {
-            return messages[prevKey];
-          }
+  findPreviousMessage(parent, comment) {
+    let prevNode = comment;
+    const parentLookup = [];
 
-          // dive deeper into the DOM and examine its children for any ngMessage
-          // comments that may be in an element that appears deeper in the list
-          if (
-            prevNode.childNodes.length &&
-            parentLookup.indexOf(prevNode) === -1
-          ) {
-            parentLookup.push(prevNode);
-            prevNode = prevNode.childNodes[prevNode.childNodes.length - 1];
-          } else if (prevNode.previousSibling) {
-            prevNode = prevNode.previousSibling;
-          } else {
-            prevNode = prevNode.parentNode;
-            parentLookup.push(prevNode);
-          }
-        }
+    while (prevNode && prevNode !== parent) {
+      const prevKey = prevNode.$$ngMessageNode;
+      if (prevKey && prevKey.length) {
+        return this.messages[prevKey];
       }
 
-      function insertMessageNode(parent, comment, key) {
-        const messageNode = messages[key];
-        if (!ctrl.head) {
-          ctrl.head = messageNode;
-        } else {
-          const match = findPreviousMessage(parent, comment);
-          if (match) {
-            messageNode.next = match.next;
-            match.next = messageNode;
-          } else {
-            messageNode.next = ctrl.head;
-            ctrl.head = messageNode;
-          }
-        }
+      if (prevNode.childNodes.length && parentLookup.indexOf(prevNode) === -1) {
+        parentLookup.push(prevNode);
+        prevNode = prevNode.childNodes[prevNode.childNodes.length - 1];
+      } else if (prevNode.previousSibling) {
+        prevNode = prevNode.previousSibling;
+      } else {
+        prevNode = prevNode.parentNode;
+        parentLookup.push(prevNode);
+      }
+    }
+  }
+
+  insertMessageNode(parent, comment, key) {
+    const messageNode = this.messages[key];
+    if (!this.head) {
+      this.head = messageNode;
+    } else {
+      const match = this.findPreviousMessage(parent, comment);
+      if (match) {
+        messageNode.next = match.next;
+        match.next = messageNode;
+      } else {
+        messageNode.next = this.head;
+        this.head = messageNode;
       }
+    }
+  }
 
-      function removeMessageNode(parent, comment, key) {
-        const messageNode = messages[key];
+  removeMessageNode(parent, comment, key) {
+    const messageNode = this.messages[key];
 
-        // This message node may have already been removed by a call to deregister()
-        if (!messageNode) return;
+    if (!messageNode) return;
 
-        const match = findPreviousMessage(parent, comment);
-        if (match) {
-          match.next = messageNode.next;
-        } else {
-          ctrl.head = messageNode.next;
-        }
-      }
-    },
+    const match = this.findPreviousMessage(parent, comment);
+    if (match) {
+      match.next = messageNode.next;
+    } else {
+      this.head = messageNode.next;
+    }
+  }
+}
+
+ngMessagesDirective.$inject = ["$animate"];
+export function ngMessagesDirective($animate) {
+  return {
+    require: "ngMessages",
+    restrict: "AE",
+    controller: ($element, $scope, $attrs) =>
+      new NgMessageCtrl($element, $scope, $attrs, $animate),
   };
 }