@angular-wave/angular.ts 0.0.66 → 0.0.67

package/src/types.js

@@ -11,12 +11,10 @@
  */
 
 /**
- *
  * @typedef {Object} Annotated
  * @property {Array<String>} $inject
- *  *
- * @typedef {Function & Annotated & Array<any>} AnnotatedFunction
  *
+ * @typedef {Function & Annotated & Array<any>} AnnotatedFunction
  */
 
 /**
@@ -316,7 +314,7 @@
 
 /**
  * Interface for a service provider.
- * @typedef {Object} ServiceProvider
+ * @typedef {Object|Function} ServiceProvider
  * @property {*} $get - The $get property that represents a service instance or a factory function.
  */
 

package/types/animations/animate-swap.d.ts

@@ -1,10 +1,7 @@
-export function ngAnimateSwapDirective($animate: any): {
-    restrict: string;
-    transclude: string;
-    terminal: boolean;
-    priority: number;
-    link(scope: any, $element: any, attrs: any, ctrl: any, $transclude: any): void;
-};
+/**
+ * @returns {import('../types').Directive}
+ */
+export function ngAnimateSwapDirective($animate: any): import("../types").Directive;
 export namespace ngAnimateSwapDirective {
     let $inject: string[];
 }

package/types/core/compile/compile.d.ts

@@ -14,9 +14,9 @@ export class $CompileProvider {
      *    are the factories.
      * @param {Function|Array} directiveFactory An injectable directive factory function. See the
      *    {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
-     * @returns {ng.ICompileProvider} Self for chaining.
+     * @returns {$CompileProvider} Self for chaining.
      */
-    directive: (name: string | any, directiveFactory: Function | any[]) => ng.ICompileProvider;
+    directive: (name: string | any, directiveFactory: Function | any[]) => $CompileProvider;
     /**
      * @ngdoc method
      * @name $compileProvider#component
@@ -122,10 +122,10 @@ export class $CompileProvider {
      * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
      *
      * @param {RegExp=} regexp New regexp to trust urls with.
-     * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+     * @returns {RegExp|$CompileProvider} Current RegExp if called without value or self for
      *    chaining otherwise.
      */
-    aHrefSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
+    aHrefSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | $CompileProvider;
     /**
      * @ngdoc method
      * @name $compileProvider#imgSrcSanitizationTrustedUrlList
@@ -143,10 +143,10 @@ export class $CompileProvider {
      * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
      *
      * @param {RegExp=} regexp New regexp to trust urls with.
-     * @returns {RegExp|ng.ICompileProvider} Current RegExp if called without value or self for
+     * @returns {RegExp|$CompileProvider} Current RegExp if called without value or self for
      *    chaining otherwise.
      */
-    imgSrcSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
+    imgSrcSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | $CompileProvider;
     strictComponentBindingsEnabled: (enabled: any) => boolean | this;
     /**
      * @ngdoc method

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

@@ -1,10 +1,5 @@
 export function identifierForController(controller: any, ident: any): any;
 /**
- * @ngdoc provider
- * @name $controllerProvider
- *
- *
- * @description
  * The {@link ng.$controller $controller service} is used by AngularJS to create new
  * controllers.
  *

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

@@ -1,36 +1,91 @@
-export class ProviderInjector {
+/**
+ * Injector for providers
+ * @extends AbstractInjector
+ */
+export class ProviderInjector extends AbstractInjector {
     /**
-     *
      * @param {Object} cache
-     * @param {boolean} strictDi
+     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
      */
     constructor(cache: any, strictDi: boolean);
+}
+/**
+ * Injector for factories and services
+ * @extends AbstractInjector
+ */
+export class InjectorService extends AbstractInjector {
+    /**
+     *
+     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
+     * @param {ProviderInjector} providerInjector
+     */
+    constructor(strictDi: boolean, providerInjector: ProviderInjector);
+    providerInjector: ProviderInjector;
+    factory(serviceName: any): any;
+    /**
+     *
+     * @param {String} name
+     * @returns {boolean}
+     */
+    has(name: string): boolean;
+}
+declare class AbstractInjector {
+    /**
+     * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
+     */
+    constructor(strictDi: boolean);
+    /**
+     * @type {Object<String, Function>}
+     */
     cache: any;
+    /** @type {boolean} */
     strictDi: boolean;
     path: any[];
-    providerCache: any;
-    modules: any;
-    factory(caller: any): void;
+    /** @type {Object.<string, import("../../types").Module>} */
+    modules: {
+        [x: string]: import("../../types").Module;
+    };
     /**
+     * Get a service by name.
      *
      * @param {String} serviceName
      * @returns {any}
      */
     get(serviceName: string): any;
-    injectionArgs(fn: any, locals: any, serviceName: any): any[];
-    invoke(fn: any, self: any, locals: any, serviceName: any): any;
-    instantiate(Type: any, locals: any, serviceName: any): any;
     /**
+     * Get the injection arguments for a function.
      *
-     * @param {String} name
-     * @returns {boolean}
+     * @param {Function|Array} fn
+     * @param {Object} locals
+     * @param {String} serviceName
+     * @returns
+     */
+    injectionArgs(fn: Function | any[], locals: any, serviceName: string): any[];
+    /**
+     * Invoke a function with optional context and locals.
+     *
+     * @param {Function|String|Array<any>} fn
+     * @param {*} [self]
+     * @param {Object} [locals]
+     * @param {String} [serviceName]
+     * @returns
+     */
+    invoke(fn: Function | string | Array<any>, self?: any, locals?: any, serviceName?: string): any;
+    /**
+     * Instantiate a type constructor with optional locals.
+     * @param {Function|Array} type
+     * @param {*} [locals]
+     * @param {String} [serviceName]
+     */
+    instantiate(type: Function | any[], locals?: any, serviceName?: string): any;
+    /**
+     * @abstract
      */
-    has(name: string): boolean;
-}
-export class InjectorService extends ProviderInjector {
-    constructor(cache: any, strictDi: any, providerInjector: any);
-    strictDi: any;
-    providerInjector: any;
-    factory(serviceName: any, caller: any): any;
     loadNewModules(): void;
+    /**
+     * @abstract
+     * @param {String} _serviceName
+     */
+    factory(_serviceName: string): void;
 }
+export {};

package/types/core/exception-handler.d.ts

@@ -2,7 +2,7 @@
  * @constructor
  * @this {ExceptionHandlerProvider}
  */
-export function $ExceptionHandlerProvider(this: import("../types").ServiceProvider): void;
+export function $ExceptionHandlerProvider(this: any): void;
 export class $ExceptionHandlerProvider {
     $get: (string | (($log: any) => ErrorHandler))[];
 }

package/types/core/parser/parse.d.ts

@@ -9,7 +9,7 @@
  * @property {function(any, any): any} assign - Assigns a value to a context. If value is not provided,
  */
 /**
- * @typedef {function} CompiledExpressionFunction
+ * @typedef {Function} CompiledExpressionFunction
  * @param {import('../scope/scope').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
  * @param {object} [locals] - local variables context object, useful for overriding values in `context`.
  * @param {any} [assign]

package/types/core/timeout/timeout.d.ts

@@ -1,29 +1,19 @@
-/**
- *
- * @param {*} $rootScope
- * @param {*} $browser
- * @param {*} $q
- * @param {*} $$q
- * @param {import('../exception-handler').ErrorHandler} $exceptionHandler
- * @returns
- */
-export function $timeout($rootScope: any, $browser: any, $q: any, $$q: any, $exceptionHandler: import("../exception-handler").ErrorHandler): {
-    (fn?: (() => any) | undefined, delay?: number | undefined, invokeApply?: boolean | undefined, ...args: any[]): Promise<any>;
-    /**
-     * @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.
-     * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
-     *   canceled.
-     */
-    cancel(promise?: Promise<any> | undefined): boolean;
-};
 export function $TimeoutProvider(): void;
 export class $TimeoutProvider {
-    $get: (string | typeof $timeout)[];
+    $get: (string | (($rootScope: import("../scope/scope").Scope, $browser: import("../../services/browser").Browser, $q: any, $$q: any, $exceptionHandler: import("../exception-handler").ErrorHandler) => {
+        (fn?: (() => any) | undefined, delay?: number | undefined, invokeApply?: boolean | undefined, ...args: any[]): Promise<any>;
+        /**
+         * @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.
+         * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
+         *   canceled.
+         */
+        cancel(promise?: Promise<any> | undefined): boolean;
+    }))[];
 }

package/types/directive/input/input.d.ts

@@ -8,136 +8,31 @@ export function countDecimals(num: any): number;
 export function isValidForStep(viewValue: any, stepBase: any, step: any): boolean;
 export function numberInputType(scope: any, element: any, attr: any, ctrl: any, $browser: any, $filter: any, $parse: any): void;
 export function rangeInputType(scope: any, element: any, attr: any, ctrl: any, $browser: any): void;
-export function hiddenInputBrowserCacheDirective(): {
+/**
+ * @param {import('../../services/browser').Browser} $browser
+ * @param {*} $filter
+ * @param {*} $parse
+ * @returns
+ */
+export function inputDirective($browser: import("../../services/browser").Browser, $filter: any, $parse: any): {
     restrict: string;
-    priority: number;
-    compile(_: any, attr: any): {
-        pre(scope: any, element: any): void;
+    require: string[];
+    link: {
+        pre(scope: any, element: any, attr: any, ctrls: any): void;
     };
 };
+export namespace inputDirective {
+    let $inject: string[];
+}
 /**
- * @ngdoc directive
- * @name ngValue
- * @restrict A
- * @priority 100
- *
- * @description
- * Binds the given expression to the value of the element.
- *
- * It is mainly used on {@link input[radio] `input[radio]`} and option elements,
- * so that when the element is selected, the {@link ngModel `ngModel`} of that element (or its
- * {@link select `select`} parent element) is set to the bound value. It is especially useful
- * for dynamically generated lists using {@link ngRepeat `ngRepeat`}, as shown below.
- *
- * It can also be used to achieve one-way binding of a given expression to an input element
- * such as an `input[text]` or a `textarea`, when that element does not use ngModel.
- *
- * @element ANY
- * @param {string=} ngValue AngularJS expression, whose value will be bound to the `value` attribute
- * and `value` property of the element.
- *
+ * @returns {import('../../types').Directive}
  */
-export function ngValueDirective(): {
-    restrict: string;
-    priority: number;
-    compile(tpl: any, tplAttr: any): (scope: any, elm: any, attr: any) => void;
-};
+export function hiddenInputBrowserCacheDirective(): import("../../types").Directive;
+/**
+ * @returns {import('../../types').Directive}
+ */
+export function ngValueDirective(): import("../../types").Directive;
 export const ISO_DATE_REGEXP: RegExp;
 export const URL_REGEXP: RegExp;
 export const EMAIL_REGEXP: RegExp;
 export const VALIDITY_STATE_PROPERTY: "validity";
-/**
- * @ngdoc directive
- * @name textarea
- * @restrict E
- *
- * @description
- * HTML textarea element control with AngularJS data-binding. The data-binding and validation
- * properties of this element are exactly the same as those of the
- * {@link ng.directive:input input element}.
- *
- * @param {string} ngModel Assignable AngularJS expression to data-bind to.
- * @param {string=} name Property name of the form under which the control is published.
- * @param {string=} required Sets `required` validation error key if the value is not entered.
- * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
- *    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
- *    `required` when you want to data-bind to the `required` attribute.
- * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
- *    minlength.
- * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
- *    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any
- *    length.
- * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
- *    does not match a RegExp found by evaluating the AngularJS expression given in the attribute value.
- *    If the expression evaluates to a RegExp object, then this is used directly.
- *    If the expression evaluates to a string, then it will be converted to a RegExp
- *    after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to
- *    `new RegExp('^abc$')`.<br />
- *    **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
- *    start at the index of the last search's match, thus not taking the whole input value into
- *    account.
- * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
- *    interaction with the input element.
- * @param {boolean=} [ngTrim=true] If set to false AngularJS will not automatically trim the input.
- *
- * @knownIssue
- *
- * When specifying the `placeholder` attribute of `<textarea>`, Internet Explorer will temporarily
- * insert the placeholder value as the textarea's content. If the placeholder value contains
- * interpolation (`{{ ... }}`), an error will be logged in the console when AngularJS tries to update
- * the value of the by-then-removed text node. This doesn't affect the functionality of the
- * textarea, but can be undesirable.
- *
- * You can work around this Internet Explorer issue by using `ng-attr-placeholder` instead of
- * `placeholder` on textareas, whenever you need interpolation in the placeholder value. You can
- * find more details on `ngAttr` in the
- * [Interpolation](guide/interpolation#-ngattr-for-binding-to-arbitrary-attributes) section of the
- * Developer Guide.
- */
-/**
- * @ngdoc directive
- * @name input
- * @restrict E
- *
- * @description
- * HTML input element control. When used together with {@link ngModel `ngModel`}, it provides data-binding,
- * input state control, and validation.
- * Input control follows HTML5 input types and polyfills the HTML5 validation behavior for older browsers.
- *
- * <div class="alert alert-warning">
- * **Note:** Not every feature offered is available for all input types.
- * Specifically, data binding and event handling via `ng-model` is unsupported for `input[file]`.
- * </div>
- *
- * @param {string} ngModel Assignable AngularJS expression to data-bind to.
- * @param {string=} name Property name of the form under which the control is published.
- * @param {string=} required Sets `required` validation error key if the value is not entered.
- * @param {boolean=} ngRequired Sets `required` attribute if set to true
- * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
- *    minlength.
- * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
- *    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any
- *    length.
- * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
- *    value does not match a RegExp found by evaluating the AngularJS expression given in the attribute value.
- *    If the expression evaluates to a RegExp object, then this is used directly.
- *    If the expression evaluates to a string, then it will be converted to a RegExp
- *    after wrapping it in `^` and `$` characters. For instance, `"abc"` will be converted to
- *    `new RegExp('^abc$')`.<br />
- *    **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
- *    start at the index of the last search's match, thus not taking the whole input value into
- *    account.
- * @param {string=} ngChange AngularJS expression to be executed when input changes due to user
- *    interaction with the input element.
- * @param {boolean=} [ngTrim=true] If set to false AngularJS will not automatically trim the input.
- *    This parameter is ignored for input[type=password] controls, which will never trim the
- *    input.
- *
- */
-export const inputDirective: (string | (($browser: any, $filter: any, $parse: any) => {
-    restrict: string;
-    require: string[];
-    link: {
-        pre(scope: any, element: any, attr: any, ctrls: any): void;
-    };
-}))[];

package/types/directive/select/select.d.ts

@@ -1,79 +1,12 @@
-export function selectDirective(): {
-    restrict: string;
-    require: string[];
-    controller: typeof SelectController;
-    priority: number;
-    link: {
-        pre: (scope: any, element: any, attr: any, ctrls: any) => void;
-        post: (scope: any, element: any, attrs: any, ctrls: any) => void;
-    };
-};
-export const optionDirective: (string | (($interpolate: any) => {
+/**
+ * @returns {import('../../types').Directive}
+ */
+export function selectDirective(): import("../../types").Directive;
+export function optionDirective($interpolate: any): {
     restrict: string;
     priority: number;
     compile(element: any, attr: any): (scope: any, element: any, attr: any) => void;
-}))[];
-declare function SelectController($element: any, $scope: any): void;
-declare class SelectController {
-    constructor($element: any, $scope: any);
-    selectValueMap: {};
-    ngModelCtrl: {
-        $setViewValue: () => void;
-        $render: () => void;
-    };
-    multiple: boolean;
-    unknownOption: JQLite;
-    hasEmptyOption: boolean;
-    emptyOption: any;
-    renderUnknownOption: (val: any) => void;
-    updateUnknownOption: (val: any) => void;
-    generateUnknownOptionValue: (val: any) => string;
-    removeUnknownOption: () => void;
-    selectEmptyOption: () => void;
-    unselectEmptyOption: () => void;
-    readValue: () => any;
-    writeValue: (value: any) => void;
-    addOption: (value: any, element: any) => void;
-    removeOption: (value: any) => void;
-    hasOption: (value: any) => boolean;
-    /**
-     * @ngdoc method
-     * @name select.SelectController#$hasEmptyOption
-     *
-     * @description
-     *
-     * Returns `true` if the select element currently has an empty option
-     * element, i.e. an option that signifies that the select is empty / the selection is null.
-     *
-     */
-    $hasEmptyOption: () => boolean;
-    /**
-     * @ngdoc method
-     * @name select.SelectController#$isUnknownOptionSelected
-     *
-     * @description
-     *
-     * Returns `true` if the select element's unknown option is selected. The unknown option is added
-     * and automatically selected whenever the select model doesn't match any option.
-     *
-     */
-    $isUnknownOptionSelected: () => boolean;
-    /**
-     * @ngdoc method
-     * @name select.SelectController#$isEmptyOptionSelected
-     *
-     * @description
-     *
-     * Returns `true` if the select element has an empty option and this empty option is currently
-     * selected. Returns `false` if the select element has no empty option or it is not selected.
-     *
-     */
-    $isEmptyOptionSelected: () => boolean;
-    selectUnknownOrEmptyOption: (value: any) => void;
-    registerOption: (optionScope: any, optionElement: any, optionAttrs: any, interpolateValueFn: any, interpolateTextFn: any) => void;
-}
-declare namespace SelectController {
+};
+export namespace optionDirective {
     let $inject: string[];
 }
-import { JQLite } from "../../shared/jqlite/jqlite";
-export {};