@angular-wave/angular.ts 0.2.1 → 0.2.3

package/types/core/controller/controller.d.ts

@@ -6,18 +6,42 @@ export function identifierForController(controller: any, ident: any): any;
  * This provider allows controller registration via the
  * {@link ng.$controllerProvider#register register} method.
  */
-export function $ControllerProvider(): void;
 export class $ControllerProvider {
     /**
+     * @type {Map<string, Function|Object>}
+     * @private
+     */
+    private controllers;
+    /**
+     * Check if a controller with a given name exists.
+     *
      * @param {string} name Controller name to check.
+     * @returns {boolean} True if the controller exists, false otherwise.
      */
-    has: (name: string) => any;
+    has(name: string): boolean;
     /**
+     * Register a controller.
+     *
      * @param {string|Object} name Controller name, or an object map of controllers where the keys are
      *    the names and the values are the constructors.
-     * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
+     * @param {Function|Array} constructor Controller constructor function (optionally decorated with DI
      *    annotations in the array notation).
      */
-    register: (name: string | any, constructor: Function | any[]) => void;
-    $get: (string | (($injector: import("../../core/di/internal-injector").InjectorService) => (expression: Function | string, locals: any, later: any, ident: any) => any))[];
+    register(name: string | any, constructor: Function | any[]): void;
+    /**
+     * $get method for dependency injection.
+     *
+     * @param {import("../../core/di/internal-injector").InjectorService} $injector
+     * @returns {Function} A service function that creates controllers.
+     */
+    $get: (string | (($injector: any) => (expression: any, locals: any, later: any, ident: any) => any))[];
+    /**
+     * Adds an identifier to the controller instance in the given locals' scope.
+     *
+     * @param {Object} locals The locals object containing the scope.
+     * @param {string} identifier The identifier to assign.
+     * @param {Object} instance The controller instance.
+     * @param {string} name The name of the controller.
+     */
+    addIdentifier(locals: any, identifier: string, instance: any, name: string): void;
 }

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/router/resolve/resolve-context.d.ts

@@ -68,18 +68,18 @@ export class ResolveContext {
      *
      * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
      *
-     * @param newResolvables the new Resolvables
+     * @param {Resolvable[]} newResolvables the new Resolvables
      * @param state Used to find the node to put the resolvable on
      */
-    addResolvables(newResolvables: any, state: any): void;
+    addResolvables(newResolvables: Resolvable[], state: any): void;
     /**
      * Returns a promise for an array of resolved path Element promises
      *
-     * @param when
+     * @param {string} when
      * @param trans
-     * @returns {Promise<any>|any}
+     * @returns {import("../../core/q/q").QPromise<any>|any}
      */
-    resolvePath(when: string, trans: any): Promise<any> | any;
+    resolvePath(when: string, trans: any): import("../../core/q/q").QPromise<any> | any;
     injector(): UIInjectorImpl;
     _injector: UIInjectorImpl;
     findNode(resolvable: any): undefined;
@@ -87,9 +87,12 @@ export class ResolveContext {
      * Gets the async dependencies of a Resolvable
      *
      * Given a Resolvable, returns its dependencies as a Resolvable[]
+     * @param {Resolvable} resolvable
+     * @returns {Resolvable[]}
      */
-    getDependencies(resolvable: any): any;
+    getDependencies(resolvable: Resolvable): Resolvable[];
 }
+import { Resolvable } from "./resolvable";
 declare class UIInjectorImpl {
     native: import("../../core/di/internal-injector").InjectorService;
     get(token: any): any;

package/types/shared/common.d.ts

@@ -177,8 +177,6 @@ export const removeFrom: any;
 export const pushTo: any;
 export function deregAll(functions: any): any;
 export function mergeR(memo: any, item: any): any;
-/** Maps an array or object properties using a callback function */
-export function mapObj(collection: any, callback: any, target: any): any;
 export function allTrueR(memo: any, elem: any): any;
 export function anyTrueR(memo: any, elem: any): any;
 export function unnestR(memo: any, elem: any): any;

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,18 +363,10 @@ 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;
-/**
- * Return the value accessible from the object by path. Any undefined traversals are ignored
- * @param {Object} obj starting object
- * @param {String} path path to traverse
- * @param {boolean} [bindFnToScope=true]
- * @returns {Object} value as accessible by path
- */
-export function getter(obj: any, path: string, bindFnToScope?: boolean): any;
 export function stringify(value: any): any;
 /**
  * @param {Number} maxDepth
@@ -542,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