@angular-wave/angular.ts 0.0.69 → 0.0.71

package/types/directive/aria/aria.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @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(): void;
+export class AriaProvider {
+    config: (newConfig: any) => void;
+    $get: () => {
+        config(key: any): any;
+        $$watchExpr: (attrName: any, ariaAttr: any, nativeAriaNodeNames: any, negate: any) => (scope: any, elem: any, attr: any) => void;
+    };
+}
+export function ngDisabledAriaDirective($aria: any): any;
+export namespace ngDisabledAriaDirective {
+    let $inject: string[];
+}
+export function ngShowAriaDirective($aria: any): any;
+export namespace ngShowAriaDirective {
+    let $inject_1: string[];
+    export { $inject_1 as $inject };
+}
+export function ngMessagesAriaDirective(): {
+    restrict: string;
+    require: string;
+    link(_scope: any, elem: any, attr: any): void;
+};
+export function ngClickAriaDirective($aria: any, $parse: any): {
+    restrict: string;
+    compile(elem: any, attr: any): (scope: any, elem: any, attr: any) => void;
+};
+export namespace ngClickAriaDirective {
+    let $inject_2: string[];
+    export { $inject_2 as $inject };
+}
+export function ngRequiredAriaDirective($aria: any): any;
+export namespace ngRequiredAriaDirective {
+    let $inject_3: string[];
+    export { $inject_3 as $inject };
+}
+export function ngCheckedAriaDirective($aria: any): any;
+export namespace ngCheckedAriaDirective {
+    let $inject_4: string[];
+    export { $inject_4 as $inject };
+}
+export function ngValueAriaDirective($aria: any): any;
+export namespace ngValueAriaDirective {
+    let $inject_5: string[];
+    export { $inject_5 as $inject };
+}
+export function ngHideAriaDirective($aria: any): any;
+export namespace ngHideAriaDirective {
+    let $inject_6: string[];
+    export { $inject_6 as $inject };
+}
+export function ngReadonlyAriaDirective($aria: any): any;
+export namespace ngReadonlyAriaDirective {
+    let $inject_7: string[];
+    export { $inject_7 as $inject };
+}
+export function ngModelAriaDirective($aria: any): {
+    restrict: string;
+    require: string;
+    priority: number;
+    compile(elem: any, attr: any): {
+        post(scope: any, elem: any, attr: any, ngModel: any): void;
+    };
+};
+export namespace ngModelAriaDirective {
+    let $inject_8: string[];
+    export { $inject_8 as $inject };
+}
+export function ngDblclickAriaDirective($aria: any): (scope: any, elem: any, attr: any) => void;
+export namespace ngDblclickAriaDirective {
+    let $inject_9: string[];
+    export { $inject_9 as $inject };
+}

package/types/directive/form/form.d.ts

@@ -11,17 +11,8 @@ export class FormController {
     $valid: boolean;
     $invalid: boolean;
     $submitted: boolean;
-    $$parentForm: {
-        $addControl: () => void;
-        $getControls: () => any;
-        $$renameControl: typeof nullFormRenameControl;
-        $removeControl: () => void;
-        $setValidity: () => void;
-        $setDirty: () => void;
-        $setPristine: () => void;
-        $setSubmitted: () => void;
-        $$setSubmitted: () => void;
-    };
+    /** @type {FormController|Object} */
+    $$parentForm: FormController | any;
     $$element: any;
     $$animate: any;
     /**

package/types/router/state/state-object.d.ts

@@ -63,8 +63,6 @@ export class StateObject {
     toString(): any;
 }
 export namespace StateObject {
-    /** Predicate which returns true if the object is an class with @State() decorator */
-    function isStateClass(stateDecl: any): boolean;
     /** Predicate which returns true if the object is a [[StateDeclaration]] object */
     function isStateDeclaration(obj: any): boolean;
     /** Predicate which returns true if the object is an internal [[StateObject]] object */

package/types/router/url/url-matcher.d.ts

@@ -135,9 +135,9 @@ export class UrlMatcher {
      *
      * @param id
      * @param opts
-     * @returns {T|Param|any|boolean|UrlMatcher|null}
+     * @returns {Param|any|boolean|UrlMatcher|null}
      */
-    parameter(id: any, opts?: {}): T | Param | any | boolean | UrlMatcher | null;
+    parameter(id: any, opts?: {}): Param | any | boolean | UrlMatcher | null;
     /**
      * Validates the input parameter values against this UrlMatcher
      *

package/types/router/url/url-rule.d.ts

@@ -130,6 +130,7 @@ export class BaseUrlRule {
     match: any;
     type: string;
     $id: number;
-    matchPriority: () => number;
+    _group: any;
     handler: any;
+    matchPriority(): number;
 }

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

@@ -2,19 +2,23 @@
  * 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|Node|JQLite|ArrayLike<Element>|(() => void)|Window} element
+ * @param {string|Node|Node[]|NodeList|JQLite|ArrayLike<Element>|(() => void)|Window} element
  * @returns {JQLite}
  */
-export function JQLite(element: string | Node | JQLite | ArrayLike<Element> | (() => void) | Window): JQLite;
+export function JQLite(element: string | Node | Node[] | NodeList | JQLite | ArrayLike<Element> | (() => void) | Window): 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|Node|JQLite|ArrayLike<Element>|(() => void)|Window} element
+     * @param {string|Node|Node[]|NodeList|JQLite|ArrayLike<Element>|(() => void)|Window} element
      * @returns {JQLite}
      */
-    constructor(element: string | Node | JQLite | ArrayLike<Element> | (() => void) | Window);
+    constructor(element: string | Node | Node[] | NodeList | JQLite | ArrayLike<Element> | (() => void) | Window);
+    /**
+     * @returns {Element[]}
+     */
+    elements(): Element[];
     /**
      * 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.

package/types/shared/utils.d.ts

@@ -106,7 +106,6 @@ export function isFunction(value: any): boolean;
 /**
  * Determines if a value is a regular expression object.
  *
- * @private
  * @param {*} value Reference to check.
  * @returns {boolean} True if `value` is a `RegExp`.
  */
@@ -114,7 +113,6 @@ export function isRegExp(value: any): boolean;
 /**
  * Checks if `obj` is a window object.
  *
- * @private
  * @param {*} obj Object to check
  * @returns {boolean} True if `obj` is a window obj.
  */

package/types/types.d.ts

@@ -41,7 +41,7 @@ export type TranscludeFunctionObject = {
      */
     isSlotFilled: (arg0: string) => boolean;
 };
-export type TranscludeFunction = (arg0: TScope, arg1: CloneAttachFunction, arg2: import("./shared/jqlite/jqlite").JQLite | undefined, arg3: string | undefined) => import("./shared/jqlite/jqlite").JQLite;
+export type TranscludeFunction = (arg0: TScope | Function, arg1: CloneAttachFunction | undefined, arg2: import("./shared/jqlite/jqlite").JQLite | undefined, arg3: string | undefined) => import("./shared/jqlite/jqlite").JQLite;
 export type transcludeWithScope = (arg0: TScope, arg1: CloneAttachFunction, arg2: import("./shared/jqlite/jqlite").JQLite | undefined, arg3: string | undefined) => import("./shared/jqlite/jqlite").JQLite;
 export type transcludeWithoutScope = (arg0: CloneAttachFunction | undefined, arg1: import("./shared/jqlite/jqlite").JQLite | undefined, arg2: string | undefined) => import("./shared/jqlite/jqlite").JQLite;
 /**

package/src/exts/aria/aria.js

@@ -1,415 +0,0 @@
-import { extend } from "../../shared/utils";
-
-const ARIA_DISABLE_ATTR = "ngAriaDisable";
-
-export function initAriaModule(angular) {
-  angular
-    .module("ngAria", ["ng"])
-    .provider("$aria", $AriaProvider)
-    .directive("ngShow", [
-      "$aria",
-      function ($aria) {
-        return $aria.$$watchExpr("ngShow", "aria-hidden", [], true);
-      },
-    ])
-    .directive("ngHide", [
-      "$aria",
-      function ($aria) {
-        return $aria.$$watchExpr("ngHide", "aria-hidden", [], false);
-      },
-    ])
-    .directive("ngValue", [
-      "$aria",
-      function ($aria) {
-        return $aria.$$watchExpr(
-          "ngValue",
-          "aria-checked",
-          nativeAriaNodeNames,
-          false,
-        );
-      },
-    ])
-    .directive("ngChecked", [
-      "$aria",
-      function ($aria) {
-        return $aria.$$watchExpr(
-          "ngChecked",
-          "aria-checked",
-          nativeAriaNodeNames,
-          false,
-        );
-      },
-    ])
-    .directive("ngReadonly", [
-      "$aria",
-      function ($aria) {
-        return $aria.$$watchExpr(
-          "ngReadonly",
-          "aria-readonly",
-          nativeAriaNodeNames,
-          false,
-        );
-      },
-    ])
-    .directive("ngRequired", [
-      "$aria",
-      function ($aria) {
-        return $aria.$$watchExpr(
-          "ngRequired",
-          "aria-required",
-          nativeAriaNodeNames,
-          false,
-        );
-      },
-    ])
-    .directive("ngModel", [
-      "$aria",
-      function ($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());
-                    },
-                  );
-                }
-              },
-            };
-          },
-        };
-      },
-    ])
-    .directive("ngDisabled", [
-      "$aria",
-      function ($aria) {
-        return $aria.$$watchExpr(
-          "ngDisabled",
-          "aria-disabled",
-          nativeAriaNodeNames,
-          false,
-        );
-      },
-    ])
-    .directive("ngMessages", () => ({
-      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");
-        }
-      },
-    }))
-    .directive("ngClick", [
-      "$aria",
-      "$parse",
-      function ($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 });
-                    }
-                  });
-                }
-              }
-            };
-          },
-        };
-      },
-    ])
-    .directive("ngDblclick", [
-      "$aria",
-      function ($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);
-          }
-        };
-      },
-    ]);
-}
-
-/**
- * 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.
- *
- */
-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,
-    };
-  };
-}

package/types/exts/aria/aria.d.ts

@@ -1 +0,0 @@
-export function initAriaModule(angular: any): void;