@angular-wave/angular.ts 0.0.61 → 0.0.63

package/types/loader.d.ts

@@ -139,7 +139,10 @@
    </file>
  </example>
  */
-export function angularInit(element: any): void;
+/**
+ * @param {Element|Document} element
+ */
+export function angularInit(element: Element | Document): void;
 /**
  * @ngdoc type
  * @name import('./types').Module
@@ -149,34 +152,6 @@ export function angularInit(element: any): void;
  * Interface for configuring AngularJS {@link angular.module modules}.
  */
 export function setupModuleLoader(window: any): any;
-/**
- * @ngdoc function
- * @name angular.errorHandlingConfig
- * @module ng
- * @kind function
- *
- * @description
- * Configure several aspects of error handling in AngularJS if used as a setter or return the
- * current configuration if used as a getter. The following options are supported:
- *
- * - **objectMaxDepth**: The maximum depth to which objects are traversed when stringified for error messages.
- *
- * Omitted or undefined options will leave the corresponding configuration values unchanged.
- *
- * @param {Object=} config - The configuration object. May only contain the options that need to be
- *     updated. Supported keys:
- *
- * * `objectMaxDepth`  **{Number}** - The max depth for stringifying objects. Setting to a
- *   non-positive or non-numeric value, removes the max depth limit.
- *   Default: 5
- *
- * * `urlErrorParamsEnabled`  **{Boolean}** - Specifies whether the generated error url will
- *   contain the parameters of the thrown error. Disabling the parameters can be useful if the
- *   generated error url is very long.
- *
- *   Default: true. When used without argument, it returns the current value.
- */
-export function errorHandlingConfig(config?: any | undefined): {};
 /**
  * @type {string} `version` from `package.json`, injected by Rollup plugin
  */
@@ -185,7 +160,6 @@ export const VERSION: string;
  * Configuration option for AngularTS bootstrap process.
  *
  * @typedef {Object} AngularBootstrapConfig
- * @property {boolean} debugInfoEnabled - Indicates whether debug information should be enabled. Setting this to `false` can improve performance but will disable some debugging features.
  * @property {boolean} [strictDi] - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
  */
 /**
@@ -196,160 +170,86 @@ export class Angular {
     cache: Map<number, import("./core/cache/cache").ExpandoStore>;
     /** @type {string} */
     version: string;
-    /** @type {bind} */
-    bind: typeof bind;
-    /** @type {equals} */
-    equals: typeof equals;
     /** @type {typeof import('./shared/jqlite/jqlite').JQLite} */
     element: typeof import("./shared/jqlite/jqlite").JQLite;
-    /** @type {extend} */
-    extend: typeof extend;
-    /** @type {forEach} */
-    forEach: typeof forEach;
-    /** @type {fromJson} */
-    fromJson: typeof fromJson;
-    /** @type {toJson} */
-    toJson: typeof toJson;
-    /** @type {identity} */
-    identity: typeof identity;
-    /** @type {isDate} */
-    isDate: typeof isDate;
-    /** @type {isDefined} */
-    isDefined: typeof isDefined;
-    /** @type {isElement} */
-    isElement: typeof isElement;
-    /** @type {isFunction} */
-    isFunction: typeof isFunction;
-    /** @type {isNumber} */
-    isNumber: typeof isNumber;
-    /** @type {isObject} */
-    isObject: typeof isObject;
-    /** @type {isString} */
-    isString: typeof isString;
-    /** @type {isUndefined} */
-    isUndefined: typeof isUndefined;
-    /** @type {merge} */
-    merge: typeof merge;
-    /** @type {errorHandlingConfig} */
-    errorHandlingConfig: typeof errorHandlingConfig;
+    /** @type {!Array<string|any>} */
+    bootsrappedModules: Array<string | any>;
     /** @type {Function} */
     doBootstrap: Function;
     /**
-   * @module angular
-   * @function bootstrap
-  
-   * @description
-   * Use this function to manually start up AngularJS application.
-   *
-   * For more information, see the {@link guide/bootstrap Bootstrap guide}.
-   *
-   * AngularJS will detect if it has been loaded into the browser more than once and only allow the
-   * first loaded script to be bootstrapped and will report a warning to the browser console for
-   * each of the subsequent scripts. This prevents strange results in applications, where otherwise
-   * multiple instances of AngularJS try to work on the DOM.
-   *
-   * <div class="alert alert-warning">
-   * **Note:** Protractor based end-to-end tests cannot use this function to bootstrap manually.
-   * They must use {@link ng.directive:ngApp ngApp}.
-   * </div>
-   *
-   * <div class="alert alert-warning">
-   * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
-   * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
-   * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
-   * causing animations to stop working and making the injector inaccessible from outside the app.
-   * </div>
-   *
-   * ```html
-   * <!doctype html>
-   * <html>
-   * <body>
-   * <div ng-controller="WelcomeController">
-   *   {{greeting}}
-   * </div>
-   *
-   * <script src="angular.js"></script>
-   * <script>
-   *   let app = angular.module('demo', [])
-   *   .controller('WelcomeController', function($scope) {
-   *       $scope.greeting = 'Welcome!';
-   *   });
-   *   angular.bootstrap(document, ['demo']);
-   * </script>
-   * </body>
-   * </html>
-   * ```
-   *
-   * @param {string | Element | Document} element DOM element which is the root of AngularJS application.
-   * @param {Array<string | Function | any[]>=} modules an array of modules to load into the application.
-   *     Each item in the array should be the name of a predefined module or a (DI annotated)
-   *     function that will be invoked by the injector as a `config` block.
-   *     See: {@link angular.module modules}
-   * @param {AngularBootstrapConfig} [config] an object for defining configuration options for the application. The
-   *     following keys are supported:
-   *
-   * * `strictDi` - disable automatic function annotation for the application. This is meant to
-   *   assist in finding bugs which break minified code. Defaults to `false`.
-   *
-   * @returns {any} InjectorService - Returns the newly created injector for this app.
-   */
-    bootstrap(element: string | Element | Document, modules?: Array<string | Function | any[]> | undefined, config?: AngularBootstrapConfig): any;
-    resumeBootstrap(extraModules: any): any;
-    /**
+     * Configure several aspects of error handling if used as a setter or return the
+     * current configuration if used as a getter.
      *
-     * @param {any[]} modules
-     * @param {boolean?} strictDi
-     * @returns {angular.auto.IInjectorService}
+     * Omitted or undefined options will leave the corresponding configuration values unchanged.
+     *
+     * @param {import('./shared/utils').ErrorHandlingConfig} [config]
+     * @returns {import('./shared/utils').ErrorHandlingConfig}
      */
-    injector(modules: any[], strictDi: boolean | null): angular.auto.IInjectorService;
+    errorHandlingConfig(config?: import("./shared/utils").ErrorHandlingConfig): import("./shared/utils").ErrorHandlingConfig;
     /**
+     * Use this function to manually start up AngularJS application.
      *
-     * The `angular.module` is a global place for creating, registering and retrieving AngularJS
-     * modules.
-     * All modules (AngularJS core or 3rd party) that should be available to an application must be
-     * registered using this mechanism.
+     * For more information, see the {@link guide/bootstrap Bootstrap guide}.
      *
-     * Passing one argument retrieves an existing {@link import('./types').Module},
-     * whereas passing more than one argument creates a new {@link import('./types').Module}
+     * AngularJS will detect if it has been loaded into the browser more than once and only allow the
+     * first loaded script to be bootstrapped and will report a warning to the browser console for
+     * each of the subsequent scripts. This prevents strange results in applications, where otherwise
+     * multiple instances of AngularJS try to work on the DOM.
      *
+     * <div class="alert alert-warning">
+     * **Note:** Protractor based end-to-end tests cannot use this function to bootstrap manually.
+     * They must use {@link ng.directive:ngApp ngApp}.
+     * </div>
      *
-     * # Module
+     * <div class="alert alert-warning">
+     * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
+     * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
+     * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
+     * causing animations to stop working and making the injector inaccessible from outside the app.
+     * </div>
      *
-     * A module is a collection of services, directives, controllers, filters, and configuration information.
-     * `angular.module` is used to configure the {@link auto.$injector $injector}.
+     * ```html
+     * <!doctype html>
+     * <html>
+     * <body>
+     * <div ng-controller="WelcomeController">
+     *   {{greeting}}
+     * </div>
      *
-     * ```js
-     * // Create a new module
-     * let myModule = angular.module('myModule', []);
-     *
-     * // register a new service
-     * myModule.value('appName', 'MyCoolApp');
-     *
-     * // configure existing services inside initialization blocks.
-     * myModule.config(['$locationProvider', function($locationProvider) {
-     *   // Configure existing providers
-     *   $locationProvider.hashPrefix('!');
-     * }]);
+     * <script src="angular.js"></script>
+     * <script>
+     *   let app = angular.module('demo', [])
+     *   .controller('WelcomeController', function($scope) {
+     *       $scope.greeting = 'Welcome!';
+     *   });
+     *   angular.bootstrap(document, ['demo']);
+     * </script>
+     * </body>
+     * </html>
      * ```
      *
-     * Then you can create an injector and load your modules like this:
+     * @param {string | Element | Document} element DOM element which is the root of AngularJS application.
+     * @param {Array<String|any>} [modules] an array of modules to load into the application.
+     *     Each item in the array should be the name of a predefined module or a (DI annotated)
+     *     function that will be invoked by the injector as a `config` block.
+     *     See: {@link angular.module modules}
+     * @param {AngularBootstrapConfig} [config] an object for defining configuration options for the application. The
+     *     following keys are supported:
      *
-     * ```js
-     * let injector = angular.injector(['ng', 'myModule'])
-     * ```
+     * * `strictDi` - disable automatic function annotation for the application. This is meant to
+     *   assist in finding bugs which break minified code. Defaults to `false`.
      *
-     * However it's more likely that you'll just use
-     * {@link ng.directive:ngApp ngApp} or
-     * {@link angular.bootstrap} to simplify this process for you.
+     * @returns {any} InjectorService - Returns the newly created injector for this app.
+     */
+    bootstrap(element: string | Element | Document, modules?: Array<string | any>, config?: AngularBootstrapConfig): any;
+    resumeBootstrap(extraModules: any): any;
+    /**
      *
-     * @param {!string} name The name of the module to create or retrieve.
-     * @param {!Array.<string>=} requires If specified then new module is being created. If
-     *        unspecified then the module is being retrieved for further configuration.
-     * @param {Function=} configFn Optional configuration function for the module. Same as
-     *        {@link import('./types').Module#config Module#config()}.
-     * @returns {import('./types').Module} new module with the {@link import('./types').Module} api.
+     * @param {any[]} modules
+     * @param {boolean?} strictDi
+     * @returns {import("./types").InjectorService}
      */
-    module(name: string, requires?: Array<string> | undefined, configFn?: Function | undefined): import("./types").Module;
+    injector(modules: any[], strictDi: boolean | null): import("./types").InjectorService;
     /**
    * @module angular
    * @function reloadWithDebugInfo
@@ -366,28 +266,8 @@ export class Angular {
  * Configuration option for AngularTS bootstrap process.
  */
 export type AngularBootstrapConfig = {
-    /**
-     * - Indicates whether debug information should be enabled. Setting this to `false` can improve performance but will disable some debugging features.
-     */
-    debugInfoEnabled: boolean;
     /**
      * - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
      */
     strictDi?: boolean;
 };
-import { bind } from "./shared/utils";
-import { equals } from "./shared/utils";
-import { extend } from "./shared/utils";
-import { forEach } from "./shared/utils";
-import { fromJson } from "./shared/utils";
-import { toJson } from "./shared/utils";
-import { identity } from "./shared/utils";
-import { isDate } from "./shared/utils";
-import { isDefined } from "./shared/utils";
-import { isElement } from "./shared/utils";
-import { isFunction } from "./shared/utils";
-import { isNumber } from "./shared/utils";
-import { isObject } from "./shared/utils";
-import { isString } from "./shared/utils";
-import { isUndefined } from "./shared/utils";
-import { merge } from "./shared/utils";

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

@@ -75,7 +75,7 @@ export class StateProvider {
      *   let result = {},
      *       views = parent(state);
      *
-     *   angular.forEach(views, function (config, name) {
+     *   forEach(views, function (config, name) {
      *     let autoName = (state.name + '.' + name).replace('.', '/');
      *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
      *     result[name] = config;

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

@@ -2,19 +2,19 @@
  * 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|Element|Comment|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+ * @param {string|Node|JQLite|ArrayLike<Element>|(() => void)} element
  * @returns {JQLite}
  */
-export function JQLite(element: string | Element | Comment | Document | Window | JQLite | ArrayLike<Element> | (() => void)): JQLite;
+export function JQLite(element: string | Node | JQLite | ArrayLike<Element> | (() => void)): 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|Element|Comment|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+     * @param {string|Node|JQLite|ArrayLike<Element>|(() => void)} element
      * @returns {JQLite}
      */
-    constructor(element: string | Element | Comment | Document | Window | JQLite | ArrayLike<Element> | (() => void));
+    constructor(element: string | Node | JQLite | ArrayLike<Element> | (() => void));
     /**
      * 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.
@@ -101,7 +101,7 @@ export class JQLite {
      * @returns {JQLite|any} - The retrieved data if acting as a getter. Otherwise, returns undefined.
      */
     data(key: string | any, value?: any): JQLite | any;
-    replaceWith(arg1: any): void | JQLite;
+    replaceWith(arg1: any): this;
     children(): JQLite;
     /**
      * @param {string} node

package/types/shared/utils.d.ts

@@ -182,7 +182,7 @@ export function snakeCase(name: any, separator: any): any;
    ```js
      let values = {name: 'misko', gender: 'male'};
      let log = [];
-     angular.forEach(values, function(value, key) {
+     forEach(values, function(value, key) {
        this.push(key + ': ' + value);
      }, log);
      expect(log).toEqual(['name: misko', 'gender: male']);
@@ -266,12 +266,6 @@ export function isNumberNaN(num: any): boolean;
  * @returns {Object}
  */
 export function inherit(parent: any, extra: any): any;
-/**
- *
- * @param {*} value to be returned.
- * @returns {*} the value passed in.
- */
-export function identity(value: any): any;
 /**
  * @param {*} value
  * @returns {() => *}
@@ -496,6 +490,11 @@ export function shallowCopy(src: any, dst: any): any;
  */
 export function assertArg(arg: any, name: any, reason: any): any;
 export function assertArgFn(arg: any, name: any, acceptArrayAnnotation: any): any;
+/**
+ * @param {ErrorHandlingConfig} [config]
+ * @returns {ErrorHandlingConfig}
+ */
+export function errorHandlingConfig(config?: ErrorHandlingConfig): ErrorHandlingConfig;
 /**
  * This object provides a utility for producing rich Error messages within
  * AngularJS. It can be called as follows:
@@ -549,4 +548,18 @@ export function directiveNormalize(name: any): any;
  */
 export function hasAnimate(node: Node): boolean;
 export const ngAttrPrefixes: string[];
-export const minErrConfig: {};
+/**
+ * Error configuration object. May only contain the options that need to be updated.
+ */
+export type ErrorHandlingConfig = {
+    /**
+     * - The max depth for stringifying objects. Setting to a
+     * non-positive or non-numeric value removes the max depth limit. Default: 5.
+     */
+    objectMaxDepth?: number | undefined;
+    /**
+     * - Specifies whether the generated error URL will
+     * contain the parameters of the thrown error. Default: true. When used without argument, it returns the current value.
+     */
+    urlErrorParamsEnabled?: boolean | undefined;
+};

package/types/types.d.ts

@@ -429,15 +429,15 @@ export type InjectorService = {
     /**
      * - Add and load new modules to the injector.
      */
-    loadNewModules: (arg0: Array<Module | string | Injectable<(...args: any[]) => void>>) => void;
+    loadNewModules?: (arg0: Array<Module | string | Injectable<(...args: any[]) => void>>) => void;
     /**
      * - A map of all the modules loaded into the injector.
      */
-    modules: {
+    modules?: {
         [x: string]: Module;
     };
     /**
      * - Indicates if strict dependency injection is enforced.
      */
-    strictDi: boolean;
+    strictDi?: boolean;
 };