@angular-wave/angular.ts 0.0.68 → 0.0.69

package/src/core/timeout/timeout.js

@@ -1,5 +1,5 @@
 import { markQExceptionHandled } from "../q/q";
-import { isDefined, isFunction, minErr, sliceArgs } from "../../shared/utils";
+import { isDefined, minErr, sliceArgs } from "../../shared/utils";
 
 const $timeoutMinErr = minErr("$timeout");
 
@@ -23,22 +23,16 @@ export function $TimeoutProvider() {
       const deferreds = {};
 
       /**
-       * @ngdoc service
-       * @name $timeout
-       *
-       * @description
+    
        * AngularJS's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
        * block and delegates any exceptions to
-       * {@link ng.$exceptionHandler $exceptionHandler} service.
+       * {@link $exceptionHandler} service.
        *
        * The return value of calling `$timeout` is a promise, which will be resolved when
        * the delay has passed and the timeout function, if provided, is executed.
        *
        * To cancel a timeout request, call `$timeout.cancel(promise)`.
        *
-       * In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
-       * synchronously flush the queue of deferred functions.
-       *
        * If you only want a promise that will be resolved after some specified delay
        * then you can call `$timeout` without the `fn` function.
        *
@@ -46,17 +40,11 @@ export function $TimeoutProvider() {
        * @param {number=} [delay=0] Delay in milliseconds.
        * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
        *   will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
-       * @returns {Promise} Promise that will be resolved when the timeout is reached. The promise
+       * @returns {import("../q/q").QPromise<any>} Promise that will be resolved when the timeout is reached. The promise
        *   will be resolved with the return value of the `fn` function.
        *
        */
       function timeout(fn, delay, invokeApply = true) {
-        if (!isFunction(fn)) {
-          invokeApply = delay;
-          delay = fn;
-          fn = () => {};
-        }
-
         const args = sliceArgs(arguments, 3);
         const skipApply = isDefined(invokeApply) && !invokeApply;
         const deferred = (skipApply ? $$q : $q).defer();
@@ -87,14 +75,10 @@ export function $TimeoutProvider() {
       }
 
       /**
-       * @ngdoc method
-       * @name $timeout#cancel
-       *
-       * @description
        * Cancels a task associated with the `promise`. As a result of this, the promise will be
        * resolved with a rejection.
        *
-       * @param {Promise=} promise Promise returned by the `$timeout` function.
+       * @param {import("../q/q").QPromise<any>} promise Promise returned by the `$timeout` function.
        * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
        *   canceled.
        */

package/src/directive/attrs/boolean.spec.js

@@ -1,6 +1,6 @@
 import { Angular } from "../../loader";
 import { createInjector } from "../../core/di/injector";
-import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
+import { dealoc } from "../../shared/jqlite/jqlite";
 
 describe("boolean attr directives", () => {
   let element, $rootScope, $compile, $rootElement;

package/src/directive/bind/bind.js

@@ -37,8 +37,8 @@ export const ngBindHtmlDirective = [
     return {
       restrict: "A",
       compile: (_tElement, tAttrs) => {
-        var ngBindHtmlGetter = $parse(tAttrs.ngBindHtml);
-        var ngBindHtmlWatch = $parse(tAttrs.ngBindHtml, (val) => val);
+        const ngBindHtmlGetter = $parse(tAttrs.ngBindHtml);
+        const ngBindHtmlWatch = $parse(tAttrs.ngBindHtml, (val) => val);
         return (scope, element) => {
           scope.$watch(ngBindHtmlWatch, () => {
             // The watched value is the unwrapped value. To avoid re-escaping, use the direct getter.

package/src/directive/class/class.js

@@ -2,7 +2,7 @@ import { forEach, isObject, isString } from "../../shared/utils";
 
 function classDirective(name, selector) {
   name = `ngClass${name}`;
-  var indexWatchExpression;
+  let indexWatchExpression;
 
   return [
     "$parse",

package/src/directive/form/form.js

@@ -153,12 +153,6 @@ FormController.prototype = {
   },
 
   /**
-   * @ngdoc method
-   * @name form.FormController#$addControl
-   * @param {object} control control object, either a {@link form.FormController} or an
-   * {@link ngModel.NgModelController}
-   *
-   * @description
    * Register a control with the form. Input elements using ngModelController do this automatically
    * when they are linked.
    *
@@ -187,11 +181,6 @@ FormController.prototype = {
   },
 
   /**
-   * @ngdoc method
-   * @name form.FormController#$getControls
-   * @returns {Array} the controls that are currently part of this form
-   *
-   * @description
    * This method returns a **shallow copy** of the controls that are currently part of this form.
    * The controls can be instances of {@link form.FormController `FormController`}
    * ({@link ngForm "child-forms"}) and of {@link ngModel.NgModelController `NgModelController`}.
@@ -222,12 +211,6 @@ FormController.prototype = {
   },
 
   /**
-   * @ngdoc method
-   * @name form.FormController#$removeControl
-   * @param {object} control control object, either a {@link form.FormController} or an
-   * {@link ngModel.NgModelController}
-   *
-   * @description
    * Deregister a control from the form.
    *
    * Input elements using ngModelController do this automatically when they are destroyed.
@@ -382,7 +365,7 @@ FormController.prototype = {
  *        (undefined),  or skipped (null). Pending is used for unfulfilled `$asyncValidators`.
  *        Skipped is used by AngularJS when validators do not run because of parse errors and when
  *        `$asyncValidators` do not run because any of the `$validators` failed.
- * @param {NgModelController | FormController} controller - The controller whose validity state is
+ * @param {import("../model/model").NgModelController | FormController} controller - The controller whose validity state is
  *        triggering the change.
  */
 addSetValidityMethod({

package/src/directive/form/form.spec.js

@@ -1,7 +1,7 @@
 import { Angular } from "../../loader";
 import { createInjector } from "../../core/di/injector";
 import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
-import { FormController } from "../../directive/form/form";
+import { FormController } from "./form";
 
 describe("form", () => {
   let doc;
@@ -679,7 +679,7 @@ describe("form", () => {
       $compile(doc)(scope);
       scope.$apply();
 
-      var parent = scope.parent,
+      const parent = scope.parent,
         child = scope.child;
 
       expect(parent).toBeDefined();

package/src/directive/include/include.js

@@ -7,6 +7,13 @@ export const ngIncludeDirective = [
   "$templateRequest",
   "$anchorScroll",
   "$animate",
+  /**
+   *
+   * @param {*} $templateRequest
+   * @param {import("../../services/anchor-scroll").AnchorScrollFunction} $anchorScroll
+   * @param {*} $animate
+   * @returns
+   */
   ($templateRequest, $anchorScroll, $animate) => ({
     restrict: "ECA",
     priority: 400,

package/src/directive/input/input.js

@@ -203,7 +203,7 @@ export function weekParser(isoWeek, existingDate) {
 
   function getFirstThursdayOfYear(year) {
     // 0 = index of January
-    var dayOfWeekOnFirst = new Date(year, 0, 1).getDay();
+    const dayOfWeekOnFirst = new Date(year, 0, 1).getDay();
     // 4 = index of Thursday (+1 to account for 1st = 5)
     // 11 = index of *next* Thursday (+1 account for 1st = 12)
     return new Date(

package/src/{exts → directive}/messages/messages.html

@@ -10,7 +10,10 @@
     <script src="/jasmine/jasmine-5.1.2/jasmine-html.js"></script>
     <script src="/jasmine/jasmine-5.1.2/boot0.js"></script>
     <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
-    <script type="module" src="/src/exts/messages/messages.spec.js"></script>
+    <script
+      type="module"
+      src="/src/directive/messages/messages.spec.js"
+    ></script>
   </head>
   <body>
     <div id="dummy"></div>

package/src/directive/messages/messages.js

@@ -0,0 +1,346 @@
+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: [
+      "$element",
+      "$scope",
+      "$attrs",
+      function ($element, $scope, $attrs) {
+        const ctrl = this;
+        let latestKey = 0;
+        let nextAttachId = 0;
+        this.head = undefined;
+        this.default = undefined;
+
+        this.getAttachId = function getAttachId() {
+          return nextAttachId++;
+        };
+
+        const messages = (this.messages = {});
+        let renderLater;
+        let cachedCollection;
+
+        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();
+                  }
+                }
+              });
+            }
+
+            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);
+            }
+
+            messageItem = messageItem.next;
+          }
+
+          forEach(unmatchedMessages, (messageCtrl) => {
+            messageCtrl.detach();
+          });
+
+          const messageMatched = unmatchedMessages.length !== totalMessages;
+          const attachDefault =
+            ctrl.default && !messageMatched && truthyKeys > 0;
+
+          if (attachDefault) {
+            ctrl.default.attach();
+          } else if (ctrl.default) {
+            ctrl.default.detach();
+          }
+
+          if (messageMatched || attachDefault) {
+            $animate.setClass($element, ACTIVE_CLASS, INACTIVE_CLASS);
+          } else {
+            $animate.setClass($element, INACTIVE_CLASS, ACTIVE_CLASS);
+          }
+        };
+
+        $scope.$watchCollection($attrs.ngMessages || $attrs.for, ctrl.render);
+
+        this.reRender = function () {
+          if (!renderLater) {
+            renderLater = true;
+            $scope.$evalAsync(() => {
+              if (renderLater && cachedCollection) {
+                ctrl.render(cachedCollection);
+              }
+            });
+          }
+        };
+
+        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++;
+          }
+
+          ctrl.reRender();
+        };
+
+        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();
+        };
+
+        function findPreviousMessage(parent, comment) {
+          let prevNode = comment;
+          const parentLookup = [];
+
+          while (prevNode && prevNode !== parent) {
+            const prevKey = prevNode.$$ngMessageNode;
+            if (prevKey && prevKey.length) {
+              return messages[prevKey];
+            }
+
+            // 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);
+            }
+          }
+        }
+
+        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;
+            }
+          }
+        }
+
+        function removeMessageNode(parent, comment, key) {
+          const messageNode = messages[key];
+
+          // This message node may have already been removed by a call to deregister()
+          if (!messageNode) return;
+
+          const match = findPreviousMessage(parent, comment);
+          if (match) {
+            match.next = messageNode.next;
+          } else {
+            ctrl.head = messageNode.next;
+          }
+        }
+      },
+    ],
+  };
+
+  function isAttrTruthy(scope, attr) {
+    return (
+      (isString(attr) && attr.length === 0) || // empty attribute
+      truthy(scope.$eval(attr))
+    );
+  }
+
+  function truthy(val) {
+    return isString(val) ? val.length : !!val;
+  }
+}
+
+ngMessagesIncludeDirective.$inject = ["$templateRequest", "$compile"];
+export function ngMessagesIncludeDirective($templateRequest, $compile) {
+  return {
+    restrict: "AE",
+    require: "^^ngMessages", // we only require this for validation sake
+    link($scope, element, attrs) {
+      const src = attrs.ngMessagesInclude || attrs.src;
+      $templateRequest(src).then((html) => {
+        if ($scope.$$destroyed) return;
+        if (isString(html) && !html.trim()) {
+          // Empty template - nothing to compile
+        } else {
+          // Non-empty template - compile and link
+          $compile(html)($scope, (contents) => {
+            element.after(contents);
+          });
+        }
+      });
+    },
+  };
+}
+
+export const ngMessageDirective = ngMessageDirectiveFactory(false);
+export const ngMessageExpDirective = ngMessageDirectiveFactory(false);
+export const ngMessageDefaultDirective = ngMessageDirectiveFactory(true);
+
+function ngMessageDirectiveFactory(isDefault) {
+  return [
+    "$animate",
+    function ($animate) {
+      return {
+        restrict: "AE",
+        transclude: "element",
+        priority: 1, // must run before ngBind, otherwise the text is set on the comment
+        terminal: true,
+        require: "^^ngMessages",
+        link(scope, element, attrs, ngMessagesCtrl, $transclude) {
+          let commentNode;
+          let records;
+          let staticExp;
+          let dynamicExp;
+
+          if (!isDefault) {
+            commentNode = element[0];
+            staticExp = attrs.ngMessage || attrs.when;
+            dynamicExp = attrs.ngMessageExp || attrs.whenExp;
+
+            const assignRecords = function (items) {
+              records = items
+                ? Array.isArray(items)
+                  ? items
+                  : items.split(/[\s,]+/)
+                : null;
+              ngMessagesCtrl.reRender();
+            };
+
+            if (dynamicExp) {
+              assignRecords(scope.$eval(dynamicExp));
+              scope.$watchCollection(dynamicExp, assignRecords);
+            } else {
+              assignRecords(staticExp);
+            }
+          }
+
+          let currentElement;
+          let messageCtrl;
+          ngMessagesCtrl.register(
+            commentNode,
+            (messageCtrl = {
+              test(name) {
+                return contains(records, name);
+              },
+              attach() {
+                if (!currentElement) {
+                  $transclude((elm, newScope) => {
+                    $animate.enter(elm, null, element);
+                    currentElement = elm;
+
+                    // Each time we attach this node to a message we get a new id that we can match
+                    // when we are destroying the node later.
+                    const $$attachId = (currentElement.$$attachId =
+                      ngMessagesCtrl.getAttachId());
+
+                    // in the event that the element or a parent element is destroyed
+                    // by another structural directive then it's time
+                    // to deregister the message from the controller
+                    currentElement.on("$destroy", () => {
+                      // If the message element was removed via a call to `detach` then `currentElement` will be null
+                      // So this handler only handles cases where something else removed the message element.
+                      if (
+                        currentElement &&
+                        currentElement.$$attachId === $$attachId
+                      ) {
+                        ngMessagesCtrl.deregister(commentNode, isDefault);
+                        messageCtrl.detach();
+                      }
+                      newScope.$destroy();
+                    });
+                  });
+                }
+              },
+              detach() {
+                if (currentElement) {
+                  const elm = currentElement;
+                  currentElement = null;
+                  $animate.leave(elm);
+                }
+              },
+            }),
+            isDefault,
+          );
+
+          // We need to ensure that this directive deregisters itself when it no longer exists
+          // Normally this is done when the attached element is destroyed; but if this directive
+          // gets removed before we attach the message to the DOM there is nothing to watch
+          // in which case we must deregister when the containing scope is destroyed.
+          scope.$on("$destroy", () => {
+            ngMessagesCtrl.deregister(commentNode, isDefault);
+          });
+        },
+      };
+    },
+  ];
+
+  function contains(collection, key) {
+    if (collection) {
+      return Array.isArray(collection)
+        ? collection.indexOf(key) >= 0
+        : Object.prototype.hasOwnProperty.call(collection, key);
+    }
+  }
+}

package/src/{exts → directive}/messages/messages.spec.js

@@ -9,16 +9,13 @@ describe("ngMessages", () => {
 
   beforeEach(() => {
     window.angular = new Angular();
-    window.angular
-      .module("app", ["ng", "ngMessages"])
-      .directive("messageWrap", () => ({
-        transclude: true,
-        scope: {
-          col: "=col",
-        },
-        template:
-          '<div ng-messages="col"><ng-transclude></ng-transclude></div>',
-      }));
+    window.angular.module("app", ["ng"]).directive("messageWrap", () => ({
+      transclude: true,
+      scope: {
+        col: "=col",
+      },
+      template: '<div ng-messages="col"><ng-transclude></ng-transclude></div>',
+    }));
 
     createInjector(["app"]).invoke(
       (_$rootScope_, _$compile_, _$templateCache_) => {
@@ -932,7 +929,6 @@ describe("ngMessages", () => {
           '  <div ng-message="failed">Your value is that of failure</div>' +
           "</div>",
       )($rootScope);
-
       $rootScope.data = {
         required: true,
         failed: true,

package/src/{exts → directive}/messages/messages.test.js

@@ -1,6 +1,6 @@
 import { test, expect } from "@playwright/test";
 
-const TEST_URL = "src/exts/messages/messages.html";
+const TEST_URL = "src/directive/messages/messages.html";
 
 test("unit tests contain no errors", async ({ page }) => {
   await page.goto(TEST_URL);

package/src/directive/model-options/model-options.spec.js

@@ -1,4 +1,4 @@
-import { defaultModelOptions } from "../../directive/model-options/model-options";
+import { defaultModelOptions } from "./model-options";
 import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
 import { Angular } from "../../loader";
 import { createInjector } from "../../core/di/injector";

package/src/directive/switch/switch.spec.js

@@ -1,6 +1,6 @@
 import { Angular } from "../../loader";
 import { createInjector } from "../../core/di/injector";
-import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
+import { dealoc } from "../../shared/jqlite/jqlite";
 
 describe("ngSwitch", () => {
   let $scope;

package/src/exts/aria/aria.spec.js

@@ -1,6 +1,6 @@
 import { createInjector } from "../../core/di/injector";
 import { Angular } from "../../loader";
-import { dealoc, JQLite } from "../../shared/jqlite/jqlite";
+import { dealoc } from "../../shared/jqlite/jqlite";
 
 describe("$aria", () => {
   let scope;

package/src/filters/filter.js

@@ -161,9 +161,8 @@ function deepCompare(
 
   switch (actualType) {
     case "object":
-      var key;
       if (matchAgainstAnyProp) {
-        for (key in actual) {
+        for (let key in actual) {
           // Under certain, rare, circumstances, key may not be a string and `charAt` will be undefined
           // See: https://github.com/angular/angular.js/issues/15644
           if (
@@ -179,7 +178,7 @@ function deepCompare(
           : deepCompare(actual, expected, comparator, anyPropertyKey, false);
       }
       if (expectedType === "object") {
-        for (key in expected) {
+        for (let key in expected) {
           const expectedVal = expected[key];
           if (isFunction(expectedVal) || isUndefined(expectedVal)) {
             continue;

package/src/filters/filter.spec.js

@@ -9,7 +9,7 @@ describe("Filter: filter", () => {
   beforeEach(() => {
     window.angular = new Angular();
     window.angular.module("myModule", ["ng"]);
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     filter = injector.get("$filter")("filter");
   });
 

package/src/filters/filters.spec.js

@@ -8,7 +8,7 @@ describe("filters", () => {
   beforeEach(() => {
     window.angular = new Angular();
     window.angular.module("myModule", ["ng"]);
-    var injector = createInjector(["myModule"]);
+    const injector = createInjector(["myModule"]);
     filter = injector.get("$filter");
   });
 

package/src/filters/limit-to.spec.js

@@ -12,8 +12,8 @@ describe("Filter: limitTo", () => {
   beforeEach(() => {
     window.angular = new Angular();
     window.angular.module("myModule", ["ng"]);
-    var injector = createInjector(["myModule"]);
-    var $filter = injector.get("$filter");
+    const injector = createInjector(["myModule"]);
+    const $filter = injector.get("$filter");
 
     items = ["a", "b", "c", "d", "e", "f", "g", "h"];
     str = "tuvwxyz";

package/src/loader.js

@@ -114,7 +114,7 @@ export class Angular {
     };
 
     this.doBootstrap = function () {
-      var jqLite = JQLite(element);
+      const jqLite = JQLite(element);
 
       if (jqLite.injector()) {
         throw ngMinErr("btstrpd", "App already bootstrapped");