@angular-wave/angular.ts 0.0.68 → 0.0.70

package/src/core/q/q.js

@@ -27,6 +27,7 @@ import {
  * @property {function(((reason: any) => (QPromise<never>|QPromise<T>|T))|null): QPromise<T>|T} catch - Shorthand for promise.then(null, errorCallback).
  * @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/core/q/q.spec.js

@@ -1,4 +1,4 @@
-import { createInjector } from "../../core/di/injector";
+import { createInjector } from "../di/injector";
 import { Angular } from "../../loader";
 
 /**

package/src/core/scope/scope.js

@@ -415,7 +415,7 @@ export class Scope {
 
     lastDirtyWatch = null;
 
-    if (this.$$watchers.length == 0) {
+    if (this.$$watchers.length === 0) {
       this.$$digestWatchIndex = -1;
     }
     // we use unshift since we use a while loop in $digest for speed.
@@ -905,7 +905,6 @@ export class Scope {
   }
 
   /**
-   * @private
    * @param {ScopePhase} phase
    */
   beginPhase(phase) {

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/{exts → directive}/aria/aria.html

@@ -10,7 +10,7 @@
     <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/aria/aria.spec.js"></script>
+    <script type="module" src="/src/directive/aria/aria.spec.js"></script>
   </head>
   <body>
     <div id="dummy"></div>

package/src/directive/aria/aria.js

@@ -0,0 +1,382 @@
+import { extend } from "../../shared/utils";
+
+const ARIA_DISABLE_ATTR = "ngAriaDisable";
+
+/**
+ * Internal Utilities
+ */
+const nativeAriaNodeNames = [
+  "BUTTON",
+  "A",
+  "INPUT",
+  "TEXTAREA",
+  "SELECT",
+  "DETAILS",
+  "SUMMARY",
+];
+
+const isNodeOneOf = function (elem, nodeTypeArray) {
+  if (nodeTypeArray.indexOf(elem[0].nodeName) !== -1) {
+    return true;
+  }
+};
+/**
+ * @ngdoc provider
+ * @name $ariaProvider
+ *
+ *
+ * @description
+ *
+ * Used for configuring the ARIA attributes injected and managed by ngAria.
+ *
+ * ```js
+ * angular.module('myApp', ['ngAria'], function config($ariaProvider) {
+ *   $ariaProvider.config({
+ *     ariaValue: true,
+ *     tabindex: false
+ *   });
+ * });
+ *```
+ *
+ * ## Dependencies
+ * Requires the {@link ngAria} module to be installed.
+ *
+ */
+export function AriaProvider() {
+  let config = {
+    ariaHidden: true,
+    ariaChecked: true,
+    ariaReadonly: true,
+    ariaDisabled: true,
+    ariaRequired: true,
+    ariaInvalid: true,
+    ariaValue: true,
+    tabindex: true,
+    bindKeydown: true,
+    bindRoleForClick: true,
+  };
+
+  this.config = function (newConfig) {
+    config = extend(config, newConfig);
+  };
+
+  function watchExpr(attrName, ariaAttr, nativeAriaNodeNames, negate) {
+    return function (scope, elem, attr) {
+      if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+
+      const ariaCamelName = attr.$normalize(ariaAttr);
+      if (
+        config[ariaCamelName] &&
+        !isNodeOneOf(elem, nativeAriaNodeNames) &&
+        !attr[ariaCamelName]
+      ) {
+        scope.$watch(attr[attrName], (boolVal) => {
+          // ensure boolean value
+          boolVal = negate ? !boolVal : !!boolVal;
+          elem.attr(ariaAttr, boolVal);
+        });
+      }
+    };
+  }
+
+  this.$get = function () {
+    return {
+      config(key) {
+        return config[key];
+      },
+      $$watchExpr: watchExpr,
+    };
+  };
+}
+
+ngDisabledAriaDirective.$inject = ["$aria"];
+export function ngDisabledAriaDirective($aria) {
+  return $aria.$$watchExpr(
+    "ngDisabled",
+    "aria-disabled",
+    nativeAriaNodeNames,
+    false,
+  );
+}
+
+ngShowAriaDirective.$inject = ["$aria"];
+export function ngShowAriaDirective($aria) {
+  return $aria.$$watchExpr("ngShow", "aria-hidden", [], true);
+}
+
+export function ngMessagesAriaDirective() {
+  return {
+    restrict: "A",
+    require: "?ngMessages",
+    link(_scope, elem, attr) {
+      if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+
+      if (!elem.attr("aria-live")) {
+        elem.attr("aria-live", "assertive");
+      }
+    },
+  };
+}
+
+ngClickAriaDirective.$inject = ["$aria", "$parse"];
+export function ngClickAriaDirective($aria, $parse) {
+  return {
+    restrict: "A",
+    compile(elem, attr) {
+      if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+
+      const fn = $parse(attr.ngClick);
+      return function (scope, elem, attr) {
+        if (!isNodeOneOf(elem, nativeAriaNodeNames)) {
+          if ($aria.config("bindRoleForClick") && !elem.attr("role")) {
+            elem.attr("role", "button");
+          }
+
+          if ($aria.config("tabindex") && !elem.attr("tabindex")) {
+            elem.attr("tabindex", 0);
+          }
+
+          if (
+            $aria.config("bindKeydown") &&
+            !attr.ngKeydown &&
+            !attr.ngKeypress &&
+            !attr.ngKeyup
+          ) {
+            elem.on("keydown", (event) => {
+              const keyCode = event.which || event.keyCode;
+
+              if (keyCode === 13 || keyCode === 32) {
+                // If the event is triggered on a non-interactive element ...
+                if (
+                  nativeAriaNodeNames.indexOf(event.target.nodeName) === -1 &&
+                  !event.target.isContentEditable
+                ) {
+                  // ... prevent the default browser behavior (e.g. scrolling when pressing spacebar)
+                  // See https://github.com/angular/angular.js/issues/16664
+                  event.preventDefault();
+                }
+                scope.$apply(callback);
+              }
+
+              function callback() {
+                fn(scope, { $event: event });
+              }
+            });
+          }
+        }
+      };
+    },
+  };
+}
+
+ngRequiredAriaDirective.$inject = ["$aria"];
+export function ngRequiredAriaDirective($aria) {
+  return $aria.$$watchExpr(
+    "ngRequired",
+    "aria-required",
+    nativeAriaNodeNames,
+    false,
+  );
+}
+
+ngCheckedAriaDirective.$inject = ["$aria"];
+export function ngCheckedAriaDirective($aria) {
+  return $aria.$$watchExpr(
+    "ngChecked",
+    "aria-checked",
+    nativeAriaNodeNames,
+    false,
+  );
+}
+
+ngValueAriaDirective.$inject = ["$aria"];
+export function ngValueAriaDirective($aria) {
+  return $aria.$$watchExpr(
+    "ngValue",
+    "aria-checked",
+    nativeAriaNodeNames,
+    false,
+  );
+}
+
+ngHideAriaDirective.$inject = ["$aria"];
+export function ngHideAriaDirective($aria) {
+  return $aria.$$watchExpr("ngHide", "aria-hidden", [], false);
+}
+
+ngReadonlyAriaDirective.$inject = ["$aria"];
+export function ngReadonlyAriaDirective($aria) {
+  return $aria.$$watchExpr(
+    "ngReadonly",
+    "aria-readonly",
+    nativeAriaNodeNames,
+    false,
+  );
+}
+
+ngModelAriaDirective.$inject = ["$aria"];
+export function ngModelAriaDirective($aria) {
+  function shouldAttachAttr(attr, normalizedAttr, elem, allowNonAriaNodes) {
+    return (
+      $aria.config(normalizedAttr) &&
+      !elem.attr(attr) &&
+      (allowNonAriaNodes || !isNodeOneOf(elem, nativeAriaNodeNames)) &&
+      (elem.attr("type") !== "hidden" || elem[0].nodeName !== "INPUT")
+    );
+  }
+
+  function shouldAttachRole(role, elem) {
+    // if element does not have role attribute
+    // AND element type is equal to role (if custom element has a type equaling shape) <-- remove?
+    // AND element is not in nativeAriaNodeNames
+    return (
+      !elem.attr("role") &&
+      elem.attr("type") === role &&
+      !isNodeOneOf(elem, nativeAriaNodeNames)
+    );
+  }
+
+  function getShape(attr) {
+    const { type } = attr;
+    const { role } = attr;
+
+    return (type || role) === "checkbox" || role === "menuitemcheckbox"
+      ? "checkbox"
+      : (type || role) === "radio" || role === "menuitemradio"
+        ? "radio"
+        : type === "range" || role === "progressbar" || role === "slider"
+          ? "range"
+          : "";
+  }
+
+  return {
+    restrict: "A",
+    require: "ngModel",
+    priority: 200, // Make sure watches are fired after any other directives that affect the ngModel value
+    compile(elem, attr) {
+      if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+
+      const shape = getShape(attr);
+
+      return {
+        post(scope, elem, attr, ngModel) {
+          const needsTabIndex = shouldAttachAttr(
+            "tabindex",
+            "tabindex",
+            elem,
+            false,
+          );
+
+          function ngAriaWatchModelValue() {
+            return ngModel.$modelValue;
+          }
+
+          function getRadioReaction() {
+            // Strict comparison would cause a BC
+            elem[0].setAttribute(
+              "aria-checked",
+              (attr.value == ngModel.$viewValue).toString(),
+            );
+          }
+
+          function getCheckboxReaction() {
+            elem.attr(
+              "aria-checked",
+              (!ngModel.$isEmpty(ngModel.$viewValue)).toString(),
+            );
+          }
+
+          switch (shape) {
+            case "radio":
+            case "checkbox":
+              if (shouldAttachRole(shape, elem)) {
+                elem.attr("role", shape);
+              }
+              if (
+                shouldAttachAttr("aria-checked", "ariaChecked", elem, false)
+              ) {
+                scope.$watch(
+                  ngAriaWatchModelValue,
+                  shape === "radio" ? getRadioReaction : getCheckboxReaction,
+                );
+              }
+              if (needsTabIndex) {
+                elem.attr("tabindex", 0);
+              }
+              break;
+            case "range":
+              if (shouldAttachRole(shape, elem)) {
+                elem.attr("role", "slider");
+              }
+              if ($aria.config("ariaValue")) {
+                const needsAriaValuemin =
+                  !elem.attr("aria-valuemin") &&
+                  (Object.prototype.hasOwnProperty.call(attr, "min") ||
+                    Object.prototype.hasOwnProperty.call(attr, "ngMin"));
+                const needsAriaValuemax =
+                  !elem.attr("aria-valuemax") &&
+                  (Object.prototype.hasOwnProperty.call(attr, "max") ||
+                    Object.prototype.hasOwnProperty.call(attr, "ngMax"));
+                const needsAriaValuenow = !elem.attr("aria-valuenow");
+
+                if (needsAriaValuemin) {
+                  attr.$observe("min", (newVal) => {
+                    elem.attr("aria-valuemin", newVal);
+                  });
+                }
+                if (needsAriaValuemax) {
+                  attr.$observe("max", (newVal) => {
+                    elem.attr("aria-valuemax", newVal);
+                  });
+                }
+                if (needsAriaValuenow) {
+                  scope.$watch(ngAriaWatchModelValue, (newVal) => {
+                    elem.attr("aria-valuenow", newVal);
+                  });
+                }
+              }
+              if (needsTabIndex) {
+                elem.attr("tabindex", 0);
+              }
+              break;
+          }
+
+          if (
+            !Object.prototype.hasOwnProperty.call(attr, "ngRequired") &&
+            ngModel.$validators.required &&
+            shouldAttachAttr("aria-required", "ariaRequired", elem, false)
+          ) {
+            // ngModel.$error.required is undefined on custom controls
+            attr.$observe("required", () => {
+              elem.attr("aria-required", (!!attr.required).toString());
+            });
+          }
+
+          if (shouldAttachAttr("aria-invalid", "ariaInvalid", elem, true)) {
+            scope.$watch(
+              () => ngModel.$invalid,
+              (newVal) => {
+                elem.attr("aria-invalid", (!!newVal).toString());
+              },
+            );
+          }
+        },
+      };
+    },
+  };
+}
+
+ngDblclickAriaDirective.$inject = ["$aria"];
+export function ngDblclickAriaDirective($aria) {
+  return function (scope, elem, attr) {
+    if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+
+    if (
+      $aria.config("tabindex") &&
+      !elem.attr("tabindex") &&
+      !isNodeOneOf(elem, nativeAriaNodeNames)
+    ) {
+      elem.attr("tabindex", 0);
+    }
+  };
+}

package/src/{exts → directive}/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;
@@ -9,7 +9,7 @@ describe("$aria", () => {
 
   beforeEach(() => {
     window.angular = new Angular();
-    window.angular.module("test", ["ngAria"]);
+    window.angular.module("test", ["ng"]);
     let injector = createInjector(["test"]);
     scope = injector.get("$rootScope");
     $compile = injector.get("$compile");
@@ -340,7 +340,7 @@ describe("$aria", () => {
   describe("aria-hidden when disabled", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             ariaHidden: false,
@@ -611,7 +611,7 @@ describe("$aria", () => {
   describe("aria-checked when disabled", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             ariaChecked: false,
@@ -701,7 +701,7 @@ describe("$aria", () => {
   describe("aria-disabled when disabled", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             ariaDisabled: false,
@@ -772,7 +772,7 @@ describe("$aria", () => {
   describe("aria-invalid when disabled", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             ariaInvalid: false,
@@ -843,7 +843,7 @@ describe("$aria", () => {
   describe("aria-readonly when disabled", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             ariaReadonly: false,
@@ -908,7 +908,7 @@ describe("$aria", () => {
   describe("aria-required when disabled", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             ariaRequired: false,
@@ -1019,7 +1019,7 @@ describe("$aria", () => {
   describe("aria-value when disabled", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             ariaValue: false,
@@ -1126,7 +1126,7 @@ describe("$aria", () => {
   describe("actions when bindRoleForClick is set to false", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             bindRoleForClick: false,
@@ -1149,7 +1149,7 @@ describe("$aria", () => {
   describe("actions when bindKeydown is set to false", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             bindKeydown: false,
@@ -1186,7 +1186,7 @@ describe("$aria", () => {
   describe("tabindex when disabled", () => {
     beforeEach(() => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($ariaProvider) => {
           $ariaProvider.config({
             tabindex: false,
@@ -1216,7 +1216,7 @@ describe("$aria", () => {
   describe("ngModel", () => {
     it("should not break when manually compiling", () => {
       window.angular.module("test", [
-        "ngAria",
+        "ng",
         ($compileProvider) => {
           $compileProvider.directive("foo", () => ({
             priority: 10,

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

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

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({