@angular-wave/angular.ts 0.0.38 → 0.0.39

package/types/core/{cache.d.ts → cache/cache.d.ts}

@@ -17,9 +17,9 @@ export const EXPANDO: "ngId";
  */
 export const CACHE: Map<number, ExpandoStore>;
 export type ExpandoStore = {
-  data: {
-    [x: string]: any;
-  };
-  events: any;
-  handle: Function | null;
+    data: {
+        [x: string]: any;
+    };
+    events: any;
+    handle: Function | null;
 };

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

@@ -0,0 +1,173 @@
+export function $CompileProvider($provide: any, $$sanitizeUriProvider: any): void;
+export class $CompileProvider {
+    constructor($provide: any, $$sanitizeUriProvider: any);
+    /**
+     * @ngdoc method
+     * @name $compileProvider#directive
+     * @kind function
+     *
+     * @description
+     * Register a new directive with the compiler.
+     *
+     * @param {string|Object} name Name of the directive in camel-case (i.e. `ngBind` which will match
+     *    as `ng-bind`), or an object map of directives where the keys are the names and the values
+     *    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.
+     */
+    directive: (name: string | any, directiveFactory: Function | any[]) => ng.ICompileProvider;
+    /**
+     * @ngdoc method
+     * @name $compileProvider#component
+     * @module ng
+     * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
+     *    or an object map of components where the keys are the names and the values are the component definition objects.
+     * @param {Object} options Component definition object (a simplified
+     *    {@link ng.$compile#directive-definition-object directive definition object}),
+     *    with the following properties (all optional):
+     *
+     *    - `controller` – `{(string|function()=}` – controller constructor function that should be
+     *      associated with newly created scope or the name of a {@link ng.$compile#-controller-
+     *      registered controller} if passed as a string. An empty `noop` function by default.
+     *    - `controllerAs` – `{string=}` – identifier name for to reference the controller in the component's scope.
+     *      If present, the controller will be published to scope under the `controllerAs` name.
+     *      If not present, this will default to be `$ctrl`.
+     *    - `template` – `{string=|function()=}` – html template as a string or a function that
+     *      returns an html template as a string which should be used as the contents of this component.
+     *      Empty string by default.
+     *
+     *      If `template` is a function, then it is {@link auto.$injector#invoke injected} with
+     *      the following locals:
+     *
+     *      - `$element` - Current element
+     *      - `$attrs` - Current attributes object for the element
+     *
+     *    - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
+     *      template that should be used  as the contents of this component.
+     *
+     *      If `templateUrl` is a function, then it is {@link auto.$injector#invoke injected} with
+     *      the following locals:
+     *
+     *      - `$element` - Current element
+     *      - `$attrs` - Current attributes object for the element
+     *
+     *    - `bindings` – `{object=}` – defines bindings between DOM attributes and component properties.
+     *      Component properties are always bound to the component controller and not to the scope.
+     *      See {@link ng.$compile#-bindtocontroller- `bindToController`}.
+     *    - `transclude` – `{boolean=}` – whether {@link $compile#transclusion content transclusion} is enabled.
+     *      Disabled by default.
+     *    - `require` - `{Object<string, string>=}` - requires the controllers of other directives and binds them to
+     *      this component's controller. The object keys specify the property names under which the required
+     *      controllers (object values) will be bound. See {@link ng.$compile#-require- `require`}.
+     *    - `$...` – additional properties to attach to the directive factory function and the controller
+     *      constructor function. (This is used by the component router to annotate)
+     *
+     * @returns {ng.$compileProvider} the compile provider itself, for chaining of function calls.
+     * @description
+     * Register a **component definition** with the compiler. This is a shorthand for registering a special
+     * type of directive, which represents a self-contained UI component in your application. Such components
+     * are always isolated (i.e. `scope: {}`) and are always restricted to elements (i.e. `restrict: 'E'`).
+     *
+     * Component definitions are very simple and do not require as much configuration as defining general
+     * directives. Component definitions usually consist only of a template and a controller backing it.
+     *
+     * In order to make the definition easier, components enforce best practices like use of `controllerAs`,
+     * `bindToController`. They always have **isolate scope** and are restricted to elements.
+     *
+     * Here are a few examples of how you would usually define components:
+     *
+     * ```js
+     *   let myMod = angular.module(...);
+     *   myMod.component('myComp', {
+     *     template: '<div>My name is {{$ctrl.name}}</div>',
+     *     controller: function() {
+     *       this.name = 'shahar';
+     *     }
+     *   });
+     *
+     *   myMod.component('myComp', {
+     *     template: '<div>My name is {{$ctrl.name}}</div>',
+     *     bindings: {name: '@'}
+     *   });
+     *
+     *   myMod.component('myComp', {
+     *     templateUrl: 'views/my-comp.html',
+     *     controller: 'MyCtrl',
+     *     controllerAs: 'ctrl',
+     *     bindings: {name: '@'}
+     *   });
+     *
+     * ```
+     * For more examples, and an in-depth guide, see the {@link guide/component component guide}.
+     *
+     * <br />
+     * See also {@link ng.$compileProvider#directive $compileProvider.directive()}.
+     */
+    component: (name: string | any, options: any) => ng.$compileProvider;
+    /**
+     * @ngdoc method
+     * @name $compileProvider#aHrefSanitizationTrustedUrlList
+     * @kind function
+     *
+     * @description
+     * Retrieves or overrides the default regular expression that is used for determining trusted safe
+     * urls during a[href] sanitization.
+     *
+     * The sanitization is a security measure aimed at preventing XSS attacks via html links.
+     *
+     * Any url about to be assigned to a[href] via data-binding is first normalized and turned into
+     * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationTrustedUrlList`
+     * regular expression. If a match is found, the original url is written into the dom. Otherwise,
+     * 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
+     *    chaining otherwise.
+     */
+    aHrefSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
+    /**
+     * @ngdoc method
+     * @name $compileProvider#imgSrcSanitizationTrustedUrlList
+     * @kind function
+     *
+     * @description
+     * Retrieves or overrides the default regular expression that is used for determining trusted safe
+     * urls during img[src] sanitization.
+     *
+     * The sanitization is a security measure aimed at prevent XSS attacks via html links.
+     *
+     * Any url about to be assigned to img[src] via data-binding is first normalized and turned into
+     * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationTrustedUrlList`
+     * regular expression. If a match is found, the original url is written into the dom. Otherwise,
+     * 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
+     *    chaining otherwise.
+     */
+    imgSrcSanitizationTrustedUrlList: (regexp?: RegExp | undefined) => RegExp | ng.ICompileProvider;
+    debugInfoEnabled: (enabled: any) => boolean | this;
+    strictComponentBindingsEnabled: (enabled: any) => boolean | this;
+    /**
+     * @ngdoc method
+     * @name $compileProvider#addPropertySecurityContext
+     * @description
+     *
+     * Defines the security context for DOM properties bound by ng-prop-*.
+     *
+     * @param {string} elementName The element name or '*' to match any element.
+     * @param {string} propertyName The DOM property name.
+     * @param {string} ctx The {@link $sce} security context in which this value is safe for use, e.g. `$sce.URL`
+     * @returns {object} `this` for chaining
+     */
+    addPropertySecurityContext: (elementName: string, propertyName: string, ctx: string) => object;
+    $get: (string | (($injector: any, $interpolate: any, $exceptionHandler: any, $templateRequest: any, $parse: any, $controller: any, $rootScope: any, $sce: any, $animate: any) => ($compileNodes: string | NodeList, transcludeFn: any, maxPriority: any, ignoreDirective: any, previousCompileContext: any) => (scope: any, cloneConnectFn: any, options: any) => any))[];
+}
+export namespace $CompileProvider {
+    let $inject: string[];
+}
+/**
+ * Function that aggregates all linking fns for a compilation root (nodeList)
+ */
+export type CompositeLinkFn = Function;

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

@@ -0,0 +1,32 @@
+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.
+ *
+ * This provider allows controller registration via the
+ * {@link ng.$controllerProvider#register register} method.
+ */
+export function $ControllerProvider(): void;
+export class $ControllerProvider {
+    /**
+     * @ngdoc method
+     * @name $controllerProvider#has
+     * @param {string} name Controller name to check.
+     */
+    has: (name: string) => any;
+    /**
+     * @ngdoc method
+     * @name $controllerProvider#register
+     * @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
+     *    annotations in the array notation).
+     */
+    register: (name: string | any, constructor: Function | any[]) => void;
+    $get: (string | (($injector: any) => (expression: Function | string, locals: any, later: any, ident: any) => any))[];
+}

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

@@ -42,5 +42,5 @@
  */
 export function $ExceptionHandlerProvider(): void;
 export class $ExceptionHandlerProvider {
-  $get: (string | (($log: any) => (...args: any[]) => void))[];
+    $get: (string | (($log: any) => (...args: any[]) => void))[];
 }

package/types/core/filter/filter.d.ts

@@ -0,0 +1,9 @@
+export function $FilterProvider($provide: any): void;
+export class $FilterProvider {
+    constructor($provide: any);
+    register: (name: any, factory: any) => any;
+    $get: (string | (($injector: any) => (name: any) => any))[];
+}
+export namespace $FilterProvider {
+    let $inject: string[];
+}

package/types/core/{interpolate.d.ts → interpolate/interpolate.d.ts}

@@ -17,43 +17,28 @@
  */
 export function $InterpolateProvider(): void;
 export class $InterpolateProvider {
-  /**
-   * @ngdoc method
-   * @name $interpolateProvider#startSymbol
-   * @description
-   * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
-   *
-   * @param {string=} value new value to set the starting symbol to.
-   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
-   */
-  startSymbol: (
-    value?: string | undefined,
-  ) => string | (Window & typeof globalThis);
-  /**
-   * @ngdoc method
-   * @name $interpolateProvider#endSymbol
-   * @description
-   * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
-   *
-   * @param {string=} value new value to set the ending symbol to.
-   * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
-   */
-  endSymbol: (
-    value?: string | undefined,
-  ) => string | (Window & typeof globalThis);
-  $get: (
-    | string
-    | ((
-        $parse: any,
-        $exceptionHandler: any,
-        $sce: any,
-      ) => {
-        (
-          text: string,
-          mustHaveExpression?: boolean | undefined,
-          trustedContext?: string | undefined,
-          allOrNothing?: boolean | undefined,
-        ): (arg0: context) => any;
+    /**
+     * @ngdoc method
+     * @name $interpolateProvider#startSymbol
+     * @description
+     * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
+     *
+     * @param {string=} value new value to set the starting symbol to.
+     * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+     */
+    startSymbol: (value?: string | undefined) => string | (Window & typeof globalThis);
+    /**
+     * @ngdoc method
+     * @name $interpolateProvider#endSymbol
+     * @description
+     * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
+     *
+     * @param {string=} value new value to set the ending symbol to.
+     * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
+     */
+    endSymbol: (value?: string | undefined) => string | (Window & typeof globalThis);
+    $get: (string | (($parse: any, $exceptionHandler: any, $sce: any) => {
+        (text: string, mustHaveExpression?: boolean | undefined, trustedContext?: string | undefined, allOrNothing?: boolean | undefined): (arg0: context) => any;
         /**
          * @ngdoc method
          * @name $interpolate#startSymbol
@@ -78,6 +63,5 @@ export class $InterpolateProvider {
          * @returns {string} end symbol.
          */
         endSymbol(): string;
-      })
-  )[];
+    }))[];
 }

package/types/core/interval/interval-factory.d.ts

@@ -0,0 +1,4 @@
+export function $$IntervalFactoryProvider(): void;
+export class $$IntervalFactoryProvider {
+    $get: (string | (($browser: any, $q: any, $$q: any, $rootScope: any) => (setIntervalFn: any, clearIntervalFn: any) => (fn: any, delay: any, count: any, invokeApply: any, ...args: any[]) => any))[];
+}

package/types/core/{interval.d.ts → interval/interval.d.ts}

@@ -1,4 +1,4 @@
 export function $IntervalProvider(): void;
 export class $IntervalProvider {
-  $get: (string | (($$intervalFactory: any) => any))[];
+    $get: (string | (($$intervalFactory: any) => any))[];
 }

package/types/core/location/location.d.ts

@@ -0,0 +1,209 @@
+/**
+ *
+ * @param {string} base
+ * @param {string} url
+ * @returns {string} returns text from `url` after `base` or `undefined` if it does not begin with
+ *                   the expected string.
+ */
+export function stripBaseUrl(base: string, url: string): string;
+export function stripHash(url: any): any;
+export function stripFile(url: any): any;
+export function serverBase(url: any): any;
+/**
+ * LocationHtml5Url represents a URL
+ * This object is exposed as $location service when HTML5 mode is enabled and supported
+ *
+ * @constructor
+ * @param {string} appBase application base URL
+ * @param {string} appBaseNoFile application base URL stripped of any filename
+ * @param {string} basePrefix URL path prefix
+ */
+export function LocationHtml5Url(appBase: string, appBaseNoFile: string, basePrefix: string): void;
+export class LocationHtml5Url {
+    /**
+     * LocationHtml5Url represents a URL
+     * This object is exposed as $location service when HTML5 mode is enabled and supported
+     *
+     * @constructor
+     * @param {string} appBase application base URL
+     * @param {string} appBaseNoFile application base URL stripped of any filename
+     * @param {string} basePrefix URL path prefix
+     */
+    constructor(appBase: string, appBaseNoFile: string, basePrefix: string);
+    $$html5: boolean;
+    /**
+     * Parse given HTML5 (regular) URL string into properties
+     * @param {string} url HTML5 URL
+     * @private
+     */
+    private $$parse;
+    $$normalizeUrl: (url: any) => string;
+    $$parseLinkUrl: (url: any, relHref: any) => boolean;
+}
+/**
+ * LocationHashbangUrl represents URL
+ * This object is exposed as $location service when developer doesn't opt into html5 mode.
+ * It also serves as the base class for html5 mode fallback on legacy browsers.
+ *
+ * @constructor
+ * @param {string} appBase application base URL
+ * @param {string} appBaseNoFile application base URL stripped of any filename
+ * @param {string} hashPrefix hashbang prefix
+ */
+export function LocationHashbangUrl(appBase: string, appBaseNoFile: string, hashPrefix: string): void;
+export class LocationHashbangUrl {
+    /**
+     * LocationHashbangUrl represents URL
+     * This object is exposed as $location service when developer doesn't opt into html5 mode.
+     * It also serves as the base class for html5 mode fallback on legacy browsers.
+     *
+     * @constructor
+     * @param {string} appBase application base URL
+     * @param {string} appBaseNoFile application base URL stripped of any filename
+     * @param {string} hashPrefix hashbang prefix
+     */
+    constructor(appBase: string, appBaseNoFile: string, hashPrefix: string);
+    /**
+     * Parse given hashbang URL into properties
+     * @param {string} url Hashbang URL
+     * @private
+     */
+    private $$parse;
+    $$normalizeUrl: (url: any) => string;
+    $$parseLinkUrl: (url: any) => boolean;
+}
+/**
+ * LocationHashbangUrl represents URL
+ * This object is exposed as $location service when html5 history api is enabled but the browser
+ * does not support it.
+ *
+ * @constructor
+ * @param {string} appBase application base URL
+ * @param {string} appBaseNoFile application base URL stripped of any filename
+ * @param {string} hashPrefix hashbang prefix
+ */
+export function LocationHashbangInHtml5Url(appBase: string, appBaseNoFile: string, hashPrefix: string, ...args: any[]): void;
+export class LocationHashbangInHtml5Url {
+    /**
+     * LocationHashbangUrl represents URL
+     * This object is exposed as $location service when html5 history api is enabled but the browser
+     * does not support it.
+     *
+     * @constructor
+     * @param {string} appBase application base URL
+     * @param {string} appBaseNoFile application base URL stripped of any filename
+     * @param {string} hashPrefix hashbang prefix
+     */
+    constructor(appBase: string, appBaseNoFile: string, hashPrefix: string, ...args: any[]);
+    $$html5: boolean;
+    $$parseLinkUrl: (url: any, relHref: any) => boolean;
+    $$normalizeUrl: (url: any) => string;
+}
+/**
+ * @ngdoc service
+ * @name $location
+ *
+ * @requires $rootElement
+ *
+ * @description
+ * The $location service parses the URL in the browser address bar (based on the
+ * [window.location](https://developer.mozilla.org/en/window.location)) and makes the URL
+ * available to your application. Changes to the URL in the address bar are reflected into
+ * $location service and changes to $location are reflected into the browser address bar.
+ *
+ * **The $location service:**
+ *
+ * - Exposes the current URL in the browser address bar, so you can
+ *   - Watch and observe the URL.
+ *   - Change the URL.
+ * - Synchronizes the URL with the browser when the user
+ *   - Changes the address bar.
+ *   - Clicks the back or forward button (or clicks a History link).
+ *   - Clicks on a link.
+ * - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
+ *
+ * For more information see {@link guide/$location Developer Guide: Using $location}
+ */
+/**
+ * @ngdoc provider
+ * @name $locationProvider
+ *
+ *
+ * @description
+ * Use the `$locationProvider` to configure how the application deep linking paths are stored.
+ */
+export function $LocationProvider(): void;
+export class $LocationProvider {
+    /**
+     * @ngdoc method
+     * @name $locationProvider#hashPrefix
+     * @description
+     * The default value for the prefix is `'!'`.
+     * @param {string=} prefix Prefix for hash part (containing path and search)
+     * @returns {*} current value if used as getter or itself (chaining) if used as setter
+     */
+    hashPrefix: (prefix?: string | undefined) => any;
+    /**
+     * @ngdoc method
+     * @name $locationProvider#html5Mode
+     * @description
+     * @param {(boolean|Object)=} mode If boolean, sets `html5Mode.enabled` to value.
+     *   If object, sets `enabled`, `requireBase` and `rewriteLinks` to respective values. Supported
+     *   properties:
+     *   - **enabled** – `{boolean}` – (default: false) If true, will rely on `history.pushState` to
+     *     change urls where supported. Will fall back to hash-prefixed paths in browsers that do not
+     *     support `pushState`.
+     *   - **requireBase** - `{boolean}` - (default: `true`) When html5Mode is enabled, specifies
+     *     whether or not a <base> tag is required to be present. If `enabled` and `requireBase` are
+     *     true, and a base tag is not present, an error will be thrown when `$location` is injected.
+     *     See the {@link guide/$location $location guide for more information}
+     *   - **rewriteLinks** - `{boolean|string}` - (default: `true`) When html5Mode is enabled,
+     *     enables/disables URL rewriting for relative links. If set to a string, URL rewriting will
+     *     only happen on links with an attribute that matches the given string. For example, if set
+     *     to `'internal-link'`, then the URL will only be rewritten for `<a internal-link>` links.
+     *     Note that [attribute name normalization](guide/directive#normalization) does not apply
+     *     here, so `'internalLink'` will **not** match `'internal-link'`.
+     *
+     * @returns {Object} html5Mode object if used as getter or itself (chaining) if used as setter
+     */
+    html5Mode: (mode?: (boolean | any) | undefined) => any;
+    /**
+     * @ngdoc event
+     * @name $location#$locationChangeStart
+     * @eventType broadcast on root scope
+     * @description
+     * Broadcasted before a URL will change.
+     *
+     * This change can be prevented by calling
+     * `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
+     * details about event object. Upon successful change
+     * {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
+     *
+     * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
+     * the browser supports the HTML5 History API.
+     *
+     * @param {Object} angularEvent Synthetic event object.
+     * @param {string} newUrl New URL
+     * @param {string=} oldUrl URL that was before it was changed.
+     * @param {string=} newState New history state object
+     * @param {string=} oldState History state object that was before it was changed.
+     */
+    /**
+     * @ngdoc event
+     * @name $location#$locationChangeSuccess
+     * @eventType broadcast on root scope
+     * @description
+     * Broadcasted after a URL was changed.
+     *
+     * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
+     * the browser supports the HTML5 History API.
+     *
+     * @param {Object} angularEvent Synthetic event object.
+     * @param {string} newUrl New URL
+     * @param {string=} oldUrl URL that was before it was changed.
+     * @param {string=} newState New history state object
+     * @param {string=} oldState History state object that was before it was changed.
+     */
+    $get: (string | (($rootScope: any, $browser: any, $rootElement: any) => LocationHtml5Url | LocationHashbangUrl))[];
+}
+export const PATH_MATCH: RegExp;