@angular-wave/angular.ts 0.2.2 → 0.2.3

package/types/core/di/internal-injector.d.ts

@@ -24,7 +24,7 @@ export class InjectorService extends AbstractInjector {
     factory(serviceName: any): any;
     /**
      *
-     * @param {String} name
+     * @param {string} name
      * @returns {boolean}
      */
     has(name: string): boolean;
@@ -48,7 +48,7 @@ declare class AbstractInjector {
     /**
      * Get a service by name.
      *
-     * @param {String} serviceName
+     * @param {string} serviceName
      * @returns {any}
      */
     get(serviceName: string): any;
@@ -57,7 +57,7 @@ declare class AbstractInjector {
      *
      * @param {Function|Array} fn
      * @param {Object} locals
-     * @param {String} serviceName
+     * @param {string} serviceName
      * @returns
      */
     injectionArgs(fn: Function | any[], locals: any, serviceName: string): any[];
@@ -67,7 +67,7 @@ declare class AbstractInjector {
      * @param {Function|String|Array<any>} fn
      * @param {*} [self]
      * @param {Object} [locals]
-     * @param {String} [serviceName]
+     * @param {string} [serviceName]
      * @returns
      */
     invoke(fn: Function | string | Array<any>, self?: any, locals?: any, serviceName?: string): any;
@@ -75,7 +75,7 @@ declare class AbstractInjector {
      * Instantiate a type constructor with optional locals.
      * @param {Function|Array} type
      * @param {*} [locals]
-     * @param {String} [serviceName]
+     * @param {string} [serviceName]
      */
     instantiate(type: Function | any[], locals?: any, serviceName?: string): any;
     /**
@@ -84,7 +84,7 @@ declare class AbstractInjector {
     loadNewModules(): void;
     /**
      * @abstract
-     * @param {String} _serviceName
+     * @param {string} _serviceName
      */
     factory(_serviceName: string): void;
 }

package/types/core/di/ng-module.d.ts

@@ -16,8 +16,8 @@ export const CONTROLLER_LITERAL: "$controllerProvider";
  */
 export class NgModule {
     /**
-     * @param {String} name - Name of the module
-     * @param {Array<String>} requires - List of modules which the injector will load before the current module
+     * @param {string} name - Name of the module
+     * @param {Array<string>} requires - List of modules which the injector will load before the current module
      * @param {Function} [configFn]
      */
     constructor(name: string, requires: Array<string>, configFn?: Function);

package/types/directive/class/class.d.ts

@@ -1,100 +1,3 @@
-/**
- * The `ngClass` directive allows you to dynamically set CSS classes on an HTML element by databinding
- * an expression that represents all classes to be added.
- *
- * The directive operates in three different ways, depending on which of three types the expression
- * evaluates to:
- *
- * 1. If the expression evaluates to a string, the string should be one or more space-delimited class
- * names.
- *
- * 2. If the expression evaluates to an object, then for each key-value pair of the
- * object with a truthy value the corresponding key is used as a class name.
- *
- * 3. If the expression evaluates to an array, each element of the array should either be a string as in
- * type 1 or an object as in type 2. This means that you can mix strings and objects together in an array
- * to give you more control over what CSS classes appear. See the code below for an example of this.
- *
- *
- * The directive won't add duplicate classes if a particular class was already set.
- *
- * When the expression changes, the previously added classes are removed and only then are the
- * new classes added.
- *
- * @knownIssue
- * You should not use {@link guide/interpolation interpolation} in the value of the `class`
- * attribute, when using the `ngClass` directive on the same element.
- * See {@link guide/interpolation#known-issues here} for more info.
- *
- * @animations
- * | Animation                        | Occurs                              |
- * |----------------------------------|-------------------------------------|
- * | {@link ng.$animate#addClass addClass}       | just before the class is applied to the element   |
- * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
- * | {@link ng.$animate#setClass setClass} | just before classes are added and classes are removed from the element at the same time |
- *
- * ### ngClass and pre-existing CSS3 Transitions/Animations
-   The ngClass directive still supports CSS3 Transitions/Animations even if they do not follow the ngAnimate CSS naming structure.
-   Upon animation ngAnimate will apply supplementary CSS classes to track the start and end of an animation, but this will not hinder
-   any pre-existing CSS transitions already on the element. To get an idea of what happens during a class-based animation, be sure
-   to view the step by step details of {@link $animate#addClass $animate.addClass} and
-   {@link $animate#removeClass $animate.removeClass}.
- *
- * @param {String} ngClass {@link guide/expression Expression} to eval. The result
- *   of the evaluation can be a string representing space delimited class
- *   names, an array, or a map of class names to boolean values. In the case of a map, the
- *   names of the properties whose values are truthy will be added as css classes to the
- *   element.
- *
- */
-export const ngClassDirective: (string | (($parse: any) => {
-    restrict: string;
-    link(scope: any, element: any, attr: any): void;
-}))[];
-/**
- * The `ngClassOdd` and `ngClassEven` directives work exactly as
- * {@link ng.directive:ngClass ngClass}, except they work in
- * conjunction with `ngRepeat` and take effect only on odd (even) rows.
- *
- * This directive can be applied only within the scope of an
- * {@link ng.directive:ngRepeat ngRepeat}.
- *
- * @animations
- * | Animation                        | Occurs                              |
- * |----------------------------------|-------------------------------------|
- * | {@link ng.$animate#addClass addClass}       | just before the class is applied to the element   |
- * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
- *
- * @element ANY
- * @param {String} ngClassOdd {@link guide/expression Expression} to eval. The result
- *   of the evaluation can be a string representing space delimited class names or an array.
- *
- *
- */
-export const ngClassOddDirective: (string | (($parse: any) => {
-    restrict: string;
-    link(scope: any, element: any, attr: any): void;
-}))[];
-/**
- * The `ngClassOdd` and `ngClassEven` directives work exactly as
- * {@link ng.directive:ngClass ngClass}, except they work in
- * conjunction with `ngRepeat` and take effect only on odd (even) rows.
- *
- * This directive can be applied only within the scope of an
- * {@link ng.directive:ngRepeat ngRepeat}.
- *
- * @animations
- * | Animation                        | Occurs                              |
- * |----------------------------------|-------------------------------------|
- * | {@link ng.$animate#addClass addClass}       | just before the class is applied to the element   |
- * | {@link ng.$animate#removeClass removeClass} | just before the class is removed from the element |
- *
- * @element ANY
- * @param {String} ngClassEven {@link guide/expression Expression} to eval. The
- *   result of the evaluation can be a string representing space delimited class names or an array.
- *
- */
-export const ngClassEvenDirective: (string | (($parse: any) => {
-    restrict: string;
-    link(scope: any, element: any, attr: any): void;
-}))[];
+export const ngClassDirective: (string | (($parse: import("../../core/parser/parse.js").ParseService) => import("../../types").Directive))[];
+export const ngClassOddDirective: (string | (($parse: import("../../core/parser/parse.js").ParseService) => import("../../types").Directive))[];
+export const ngClassEvenDirective: (string | (($parse: import("../../core/parser/parse.js").ParseService) => import("../../types").Directive))[];

package/types/directive/model/model.d.ts

@@ -3,7 +3,7 @@ export function ngModelDirective($rootScope: any): {
     require: string[];
     controller: typeof NgModelController;
     priority: number;
-    compile: (element: any) => {
+    compile: (element: import("../../shared/jqlite/jqlite.js").JQLite) => {
         pre: (scope: any, _element: any, attr: any, ctrls: any) => void;
         post: (scope: any, element: any, _attr: any, ctrls: any) => void;
     };
@@ -115,11 +115,14 @@ export class NgModelController {
     $$ngModelSet: (arg0: any, arg1: any) => any;
     $$pendingDebounce: any;
     $$parserValid: boolean;
+    /** @type {string} */
     $$parserName: string;
     /** @type {number} */
     $$currentValidationRunId: number;
-    $$scope: import("../../core/scope/scope").Scope;
-    $$rootScope: import("../../core/scope/scope").Scope;
+    /** @type {Scope} */
+    $$scope: Scope;
+    /** @type {Scope} */
+    $$rootScope: Scope;
     $$attr: import("../../core/compile/attributes").Attributes;
     $$element: import("../../shared/jqlite/jqlite").JQLite;
     $$animate: any;

package/types/directive/validators/validators.d.ts

@@ -1,6 +1,6 @@
 /**
  *
- * @param {String} ngRequired AngularJS expression. If it evaluates to `true`, it sets the
+ * @param {string} ngRequired AngularJS expression. If it evaluates to `true`, it sets the
  *                                `required` attribute to the element and adds the `required`
  *                                {@link ngModel.NgModelController#$validators `validator`}.
  *
@@ -71,7 +71,7 @@ export const patternDirective: (string | (($parse: any) => {
     compile: (tElm: any, tAttr: any) => (scope: any, elm: any, attr: any, ctrl: any) => void;
 }))[];
 /**
- * @param {String} ngMaxlength AngularJS expression that must evaluate to a `Number` or `String`
+ * @param {string} ngMaxlength AngularJS expression that must evaluate to a `Number` or `String`
  *                                 parsable into a `Number`. Used as value for the `maxlength`
  *                                 {@link ngModel.NgModelController#$validators validator}.
  *

package/types/shared/hof.d.ts

@@ -112,5 +112,4 @@ export const propEq: any;
 export function parse(name: any): any;
 export function all(fn1: any): (arr: any) => any;
 export function is(ctor: any): (obj: any) => boolean;
-export function eq(value: any): (other: any) => boolean;
 export function val(v: any): () => any;

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

@@ -1,6 +1,6 @@
 /**
- * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
- * and execution of chain functions.
+ * JQLite is both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
+ * and execution of chains of functions.
  *
  * @param {string|Node|Node[]|NodeList|JQLite|ArrayLike<Element>|(() => void)|Window} element
  * @returns {JQLite}
@@ -8,8 +8,8 @@
 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.
+     * JQLite is both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
+     * and execution of chains of functions.
      *
      * @param {string|Node|Node[]|NodeList|JQLite|ArrayLike<Element>|(() => void)|Window} element
      * @returns {JQLite}

package/types/shared/utils.d.ts

@@ -192,7 +192,6 @@ export function snakeCase(name: any, separator: any): any;
  * @returns {Object|Array} Reference to `obj`.
  */
 export function forEach(obj: any | any[], iterator: Function, context?: any | undefined): any | any[];
-export function forEachSorted(obj: any, iterator: any, context: any): string[];
 /**
  * when using forEach the params are value, key, but it is often useful to have key, value.
  * @param {function(string, *):any} iteratorFn
@@ -364,8 +363,8 @@ export function equals(o1: any, o2: any): boolean;
 export function csp(): any;
 /**
  * throw error if the name given is hasOwnProperty
- * @param  {String} name    the name to test
- * @param  {String} context the context in which the name is used, such as module or directive
+ * @param  {string} name    the name to test
+ * @param  {string} context the context in which the name is used, such as module or directive
  */
 export function assertNotHasOwnProperty(name: string, context: string): void;
 export function stringify(value: any): any;
@@ -534,9 +533,10 @@ export function hashKey(obj: any): string;
 export function mergeClasses(a: any, b: any): any;
 /**
  * Converts all accepted directives format into proper directive name.
- * @param name Name to normalize
+ * @param {string} name Name to normalize
+ * @returns {string}
  */
-export function directiveNormalize(name: any): any;
+export function directiveNormalize(name: string): string;
 /**
  * Whether element should be animated
  * @param {Node} node