@angular-wave/angular.ts 0.0.65 → 0.0.67

package/types/directive/show-hide/show-hide.d.ts

@@ -1,228 +1,15 @@
 /**
- * @ngdoc directive
- * @name ngShow
- * @multiElement
- *
- * @description
- * The `ngShow` directive shows or hides the given HTML element based on the expression provided to
- * the `ngShow` attribute.
- *
- * The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
- * The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
- * `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
- * {@link ng.directive:ngCsp ngCsp}).
- *
- * ```html
- * <!-- when $scope.myValue is truthy (element is visible) -->
- * <div ng-show="myValue"></div>
- *
- * <!-- when $scope.myValue is falsy (element is hidden) -->
- * <div ng-show="myValue" class="ng-hide"></div>
- * ```
- *
- * When the `ngShow` expression evaluates to a falsy value then the `.ng-hide` CSS class is added
- * to the class attribute on the element causing it to become hidden. When truthy, the `.ng-hide`
- * CSS class is removed from the element causing the element not to appear hidden.
- *
- * ## Why is `!important` used?
- *
- * You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
- * `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
- * simple as changing the display style on a HTML list item would make hidden elements appear
- * visible. This also becomes a bigger issue when dealing with CSS frameworks.
- *
- * By using `!important`, the show and hide behavior will work as expected despite any clash between
- * CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
- * developer chooses to override the styling to change how to hide an element then it is just a
- * matter of using `!important` in their own CSS code.
- *
- * ### Overriding `.ng-hide`
- *
- * By default, the `.ng-hide` class will style the element with `display: none !important`. If you
- * wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
- * the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
- * `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
- *
- * ```css
- * .ng-hide:not(.ng-hide-animate) {
- *   /&#42; These are just alternative ways of hiding an element &#42;/
- *   display: block!important;
- *   position: absolute;
- *   top: -9999px;
- *   left: -9999px;
- * }
- * ```
- *
- * By default you don't need to override anything in CSS and the animations will work around the
- * display style.
- *
- * @animations
- * | Animation                                           | Occurs                                                                                                        |
- * |-----------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
- * | {@link $animate#addClass addClass} `.ng-hide`       | After the `ngShow` expression evaluates to a non truthy value and just before the contents are set to hidden. |
- * | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngShow` expression evaluates to a truthy value and just before contents are set to visible.        |
- *
- * Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
- * directive expression is true and false. This system works like the animation system present with
- * `ngClass` except that you must also include the `!important` flag to override the display
- * property so that the elements are not actually hidden during the animation.
- *
- * ```css
- * /&#42; A working example can be found at the bottom of this page. &#42;/
- * .my-element.ng-hide-add, .my-element.ng-hide-remove {
- *   transition: all 0.5s linear;
- * }
- *
- * .my-element.ng-hide-add { ... }
- * .my-element.ng-hide-add.ng-hide-add-active { ... }
- * .my-element.ng-hide-remove { ... }
- * .my-element.ng-hide-remove.ng-hide-remove-active { ... }
- * ```
- *
- * Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
- * to block during animation states - ngAnimate will automatically handle the style toggling for you.
- *
- * @element ANY
- * @param {string} ngShow If the {@link guide/expression expression} is truthy/falsy then the
- *                            element is shown/hidden respectively.
- *
- * @example
- * A simple example, animating the element's opacity:
-
-* <hr />
- *
- * @knownIssue
- *
- * ### Flickering when using ngShow to toggle between elements
- *
- * When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
- * happen that both the element to show and the element to hide are visible for a very short time.
- *
- * This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
- * are defined for {@link ngShow} / {@link ngHide}.
- *
- * There are several way to mitigate this problem:
- *
- * - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
- * - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
- * - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
- * - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
- * - Define an animation on the affected elements.
+ * @returns {import('../../types').Directive}
  */
-export const ngShowDirective: (string | (($animate: any) => {
-    restrict: string;
-    multiElement: boolean;
-    link(scope: any, element: any, attr: any): void;
-}))[];
+export function ngShowDirective($animate: any): import("../../types").Directive;
+export namespace ngShowDirective {
+    let $inject: string[];
+}
 /**
- * @ngdoc directive
- * @name ngHide
- * @multiElement
- *
- * @description
- * The `ngHide` directive shows or hides the given HTML element based on the expression provided to
- * the `ngHide` attribute.
- *
- * The element is shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
- * The `.ng-hide` CSS class is predefined in AngularJS and sets the display style to none (using an
- * `!important` flag). For CSP mode please add `angular-csp.css` to your HTML file (see
- * {@link ng.directive:ngCsp ngCsp}).
- *
- * ```html
- * <!-- when $scope.myValue is truthy (element is hidden) -->
- * <div ng-hide="myValue" class="ng-hide"></div>
- *
- * <!-- when $scope.myValue is falsy (element is visible) -->
- * <div ng-hide="myValue"></div>
- * ```
- *
- * When the `ngHide` expression evaluates to a truthy value then the `.ng-hide` CSS class is added
- * to the class attribute on the element causing it to become hidden. When falsy, the `.ng-hide`
- * CSS class is removed from the element causing the element not to appear hidden.
- *
- * ## Why is `!important` used?
- *
- * You may be wondering why `!important` is used for the `.ng-hide` CSS class. This is because the
- * `.ng-hide` selector can be easily overridden by heavier selectors. For example, something as
- * simple as changing the display style on a HTML list item would make hidden elements appear
- * visible. This also becomes a bigger issue when dealing with CSS frameworks.
- *
- * By using `!important`, the show and hide behavior will work as expected despite any clash between
- * CSS selector specificity (when `!important` isn't used with any conflicting styles). If a
- * developer chooses to override the styling to change how to hide an element then it is just a
- * matter of using `!important` in their own CSS code.
- *
- * ### Overriding `.ng-hide`
- *
- * By default, the `.ng-hide` class will style the element with `display: none !important`. If you
- * wish to change the hide behavior with `ngShow`/`ngHide`, you can simply overwrite the styles for
- * the `.ng-hide` CSS class. Note that the selector that needs to be used is actually
- * `.ng-hide:not(.ng-hide-animate)` to cope with extra animation classes that can be added.
- *
- * ```css
- * .ng-hide:not(.ng-hide-animate) {
- *   /&#42; These are just alternative ways of hiding an element &#42;/
- *   display: block!important;
- *   position: absolute;
- *   top: -9999px;
- *   left: -9999px;
- * }
- * ```
- *
- * By default you don't need to override in CSS anything and the animations will work around the
- * display style.
- *
- * @animations
- * | Animation                                           | Occurs                                                                                                     |
- * |-----------------------------------------------------|------------------------------------------------------------------------------------------------------------|
- * | {@link $animate#addClass addClass} `.ng-hide`       | After the `ngHide` expression evaluates to a truthy value and just before the contents are set to hidden.  |
- * | {@link $animate#removeClass removeClass} `.ng-hide` | After the `ngHide` expression evaluates to a non truthy value and just before contents are set to visible. |
- *
- * Animations in `ngShow`/`ngHide` work with the show and hide events that are triggered when the
- * directive expression is true and false. This system works like the animation system present with
- * `ngClass` except that you must also include the `!important` flag to override the display
- * property so that the elements are not actually hidden during the animation.
- *
- * ```css
- * /&#42; A working example can be found at the bottom of this page. &#42;/
- * .my-element.ng-hide-add, .my-element.ng-hide-remove {
- *   transition: all 0.5s linear;
- * }
- *
- * .my-element.ng-hide-add { ... }
- * .my-element.ng-hide-add.ng-hide-add-active { ... }
- * .my-element.ng-hide-remove { ... }
- * .my-element.ng-hide-remove.ng-hide-remove-active { ... }
- * ```
- *
- * Keep in mind that, as of AngularJS version 1.3, there is no need to change the display property
- * to block during animation states - ngAnimate will automatically handle the style toggling for you.
- *
- * @element ANY
- * @param {string} ngHide If the {@link guide/expression expression} is truthy/falsy then the
- *                            element is hidden/shown respectively.
- *
- * @knownIssue
- *
- * ### Flickering when using ngHide to toggle between elements
- *
- * When using {@link ngShow} and / or {@link ngHide} to toggle between elements, it can
- * happen that both the element to show and the element to hide are visible for a very short time.
- *
- * This usually happens when the {@link ngAnimate ngAnimate module} is included, but no actual animations
- * are defined for {@link ngShow} / {@link ngHide}. Internet Explorer is affected more often than
- * other browsers.
- *
- * There are several way to mitigate this problem:
- *
- * - {@link guide/animations#how-to-selectively-enable-disable-and-skip-animations Disable animations on the affected elements}.
- * - Use {@link ngIf} or {@link ngSwitch} instead of {@link ngShow} / {@link ngHide}.
- * - Use the special CSS selector `ng-hide.ng-hide-animate` to set `{display: none}` or similar on the affected elements.
- * - Use `ng-class="{'ng-hide': expression}` instead of instead of {@link ngShow} / {@link ngHide}.
- * - Define an animation on the affected elements.
+ * @returns {import('../../types').Directive}
  */
-export const ngHideDirective: (string | (($animate: any) => {
-    restrict: string;
-    multiElement: boolean;
-    link(scope: any, element: any, attr: any): void;
-}))[];
+export function ngHideDirective($animate: any): import("../../types").Directive;
+export namespace ngHideDirective {
+    let $inject_1: string[];
+    export { $inject_1 as $inject };
+}

package/types/loader.d.ts

@@ -79,9 +79,9 @@ export class Angular {
      *
      * @param {any[]} modules
      * @param {boolean?} strictDi
-     * @returns {import("./types").InjectorService}
+     * @returns {import("./core/di/internal-injector").InjectorService}
      */
-    injector(modules: any[], strictDi: boolean | null): import("./types").InjectorService;
+    injector(modules: any[], strictDi: boolean | null): import("./core/di/internal-injector").InjectorService;
     /**
      * @param {Element|Document} element
      */
@@ -129,11 +129,11 @@ export class Angular {
      * @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
+     * @param {Array<any>|Function} [configFn] Optional configuration function for the module. Same as
      *        {@link import('./types').Module#config Module#config()}.
      * @returns {NgModule} A newly registered module.
      */
-    module(name: string, requires?: Array<string>, configFn?: Function): NgModule;
+    module(name: string, requires?: Array<string>, configFn?: Array<any> | Function): NgModule;
 }
 /**
  * Configuration option for AngularTS bootstrap process.

package/types/router/services.d.ts

@@ -1,4 +1,11 @@
-export function runBlock($injector: any, $q: any, $stateRegistry: any, $urlService: any): void;
+/**
+ *
+ * @param {import("../core/di/internal-injector").InjectorService} $injector
+ * @param {*} $q
+ * @param {*} $stateRegistry
+ * @param {*} $urlService
+ */
+export function runBlock($injector: import("../core/di/internal-injector").InjectorService, $q: any, $stateRegistry: any, $urlService: any): void;
 export namespace runBlock {
     let $inject: string[];
 }

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

@@ -57,7 +57,7 @@ export class StateBuilder {
     matcher: any;
     $injector: any;
     builders: {
-        name: (typeof nameBuilder)[];
+        name: ((state: any) => any)[];
         self: (typeof selfBuilder)[];
         parent: ((state: any) => any)[];
         data: (typeof dataBuilder)[];
@@ -81,7 +81,6 @@ export class StateBuilder {
     parentName(state: any): any;
     name(state: any): any;
 }
-declare function nameBuilder(state: any): any;
 declare function selfBuilder(state: any): any;
 declare function dataBuilder(state: any): any;
 declare function pathBuilder(state: any): any;

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

@@ -9,12 +9,12 @@ export class StateRegistry {
     states: {};
     urlService: any;
     urlServiceRules: any;
-    $injector: any;
+    $injector: import("../../core/di/internal-injector").InjectorService;
     listeners: any[];
     matcher: StateMatcher;
     builder: StateBuilder;
     stateQueue: StateQueueManager;
-    $get: (string | (($injector: any) => this))[];
+    $get: (string | (($injector: import("../../core/di/internal-injector").InjectorService) => this))[];
     /**
      * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,
      * `onRetain` callback hooks on a [[Ng1StateDeclaration]].

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

@@ -123,9 +123,9 @@ export class StateService {
     decorator(name: string, func: object): object;
     /**
      *
-     * @param {angular.Ng1StateDeclaration} definition
+     * @param {any} definition
      */
-    state(definition: angular.Ng1StateDeclaration): this;
+    state(definition: any): this;
     /**
      * Handler for when [[transitionTo]] is called with an invalid state.
      *

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

@@ -110,10 +110,10 @@ export class StateProvider {
     decorator(name: string, func: object): object;
     /**
      *
-     * @param {angular.Ng1StateDeclaration} definition
+     * @param {*} definition
      * @returns {StateProvider}
      */
-    state(definition: angular.Ng1StateDeclaration): StateProvider;
+    state(definition: any): StateProvider;
     /**
      * Registers an invalid state handler
      *

package/types/router/template-factory.d.ts

@@ -9,12 +9,12 @@
 export class TemplateFactory {
     /** @type {boolean} */
     _useHttp: boolean;
-    $get: (string | (($http: angular.IHttpService, $templateCache: angular.ITemplateCacheService, $templateRequest: angular.ITemplateRequestService, $q: angular.IQService, $injector: angular.auto.IInjectorService) => this))[];
-    $templateRequest: angular.ITemplateRequestService;
-    $http: angular.IHttpService;
-    $templateCache: angular.ITemplateCacheService;
-    $q: angular.IQService;
-    $injector: angular.auto.IInjectorService;
+    $get: (string | (($http: any, $templateCache: any, $templateRequest: any, $q: any, $injector: import("../core/di/internal-injector").InjectorService) => this))[];
+    $templateRequest: any;
+    $http: any;
+    $templateCache: any;
+    $q: any;
+    $injector: import("../core/di/internal-injector").InjectorService;
     /**
      * Forces the provider to use $http service directly
      * @param {boolean} value
@@ -27,24 +27,24 @@ export class TemplateFactory {
      * The following properties are search in the specified order, and the first one
      * that is defined is used to create the template:
      *
-     * @param {angular.Ng1ViewDeclaration} config
+     * @param {any} config
      * @param {any} params  Parameters to pass to the template function.
-     * @param {angular.ResolveContext} context The resolve context associated with the template's view
+     * @param {import("./resolve/resolve-context").ResolveContext} context The resolve context associated with the template's view
      *
      * @return {string|object}  The template html as a string, or a promise for
      * that string,or `null` if no template is configured.
      */
-    fromConfig(config: angular.Ng1ViewDeclaration, params: any, context: angular.ResolveContext): string | object;
+    fromConfig(config: any, params: any, context: import("./resolve/resolve-context").ResolveContext): string | object;
     /**
      * Creates a template from a string or a function returning a string.
      *
      * @param {string | Function} template html template as a string or function that returns an html template as a string.
-     * @param {angular.RawParams} [params] Parameters to pass to the template function.
+     * @param {any} [params] Parameters to pass to the template function.
      *
      * @return {string|object} The template html as a string, or a promise for that
      * string.
      */
-    fromString(template: string | Function, params?: angular.RawParams): string | object;
+    fromString(template: string | Function, params?: any): string | object;
     /**
      * Loads a template from the a URL via `$http` and `$templateCache`.
      *
@@ -60,11 +60,11 @@ export class TemplateFactory {
      *
      * @param {import('../types').Injectable<any>} provider Function to invoke via `locals`
      * @param {Function} injectFn a function used to invoke the template provider
-     * @param {angular.ResolveContext} context
+     * @param {import("./resolve/resolve-context").ResolveContext} context
      * @return {string|Promise.<string>} The template html as a string, or a promise
      * for that string.
      */
-    fromProvider(provider: import("../types").Injectable<any>, params: any, context: angular.ResolveContext): string | Promise<string>;
+    fromProvider(provider: import("../types").Injectable<any>, params: any, context: import("./resolve/resolve-context").ResolveContext): string | Promise<string>;
     /**
      * Creates a component's template by invoking an injectable provider function.
      *
@@ -81,13 +81,13 @@ export class TemplateFactory {
      * It analyses the component's bindings, then constructs a template that instantiates the component.
      * The template wires input and output bindings to resolves or from the parent component.
      *
-     * @param {angular.IAugmentedJQuery} ngView {object} The parent ui-view (for binding outputs to callbacks)
-     * @param {angular.ResolveContext} context The ResolveContext (for binding outputs to callbacks returned from resolves)
+     * @param {any} ngView {object} The parent ui-view (for binding outputs to callbacks)
+     * @param {import("./resolve/resolve-context").ResolveContext} context The ResolveContext (for binding outputs to callbacks returned from resolves)
      * @param {string} component {string} Component's name in camel case.
      * @param {any} [bindings] An object defining the component's bindings: {foo: '<'}
      * @return {string} The template as a string: "<component-name input1='::$resolve.foo'></component-name>".
      */
-    makeComponentTemplate(ngView: angular.IAugmentedJQuery, context: angular.ResolveContext, component: string, bindings?: any): string;
+    makeComponentTemplate(ngView: any, context: import("./resolve/resolve-context").ResolveContext, component: string, bindings?: any): string;
 }
 export type BindingTuple = {
     name: string;

package/types/router/url/url-service.d.ts

@@ -104,15 +104,15 @@ export class UrlService {
      * locationServices.url("/some/path?query=value#anchor", true);
      * ```
      *
-     * @param {string} newUrl The new value for the URL.
+     * @param {string} [newUrl] The new value for the URL.
      *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
      *               It should not include the protocol, site, port, or base path of an absolute HREF.
-     * @param {boolean} replace When true, replaces the current history entry (instead of appending it) with this new url
-     * @param {any} state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
+     * @param {boolean} [replace] When true, replaces the current history entry (instead of appending it) with this new url
+     * @param {any} [state] The history's state object, i.e., pushState (if the LocationServices implementation supports it)
      *
      * @return the url (after potentially being processed)
      */
-    url(newUrl: string, replace: boolean, state: any): any;
+    url(newUrl?: string, replace?: boolean, state?: any): any;
     /**
      * @internal
      *

package/types/services/anchor-scroll.d.ts

@@ -1,5 +1,5 @@
 export function AnchorScrollProvider(): void;
 export class AnchorScrollProvider {
     disableAutoScrolling: () => void;
-    $get: (string | (($location: angular.IRootScopeService, $rootScope: any) => (hash: any) => void))[];
+    $get: (string | (($location: any, $rootScope: import("../core/scope/scope").Scope) => (hash: any) => void))[];
 }

package/types/services/browser.d.ts

@@ -149,8 +149,6 @@ export class Browser {
     cancel: (deferId: number) => boolean;
 }
 /**
- * @typedef {import('../types').ServiceProvider} angular.BrowserProvider
- * @description
  * This object has two goals:
  *
  * - hide all the global state in the browser caused by the window object
@@ -158,15 +156,7 @@ export class Browser {
  *
  * Remove this in the future
  */
-/**
- * @constructor
- * @this {angular.BrowserProvider}
- */
-export function BrowserProvider(this: import("../types").ServiceProvider): void;
 export class BrowserProvider {
     $get: (string | (($$taskTrackerFactory: import("../core/task-tracker-factory").TaskTracker) => Browser))[];
 }
 export type UrlChangeListener = (arg0: string, arg1: string | null) => any;
-export namespace angular {
-    type BrowserProvider = import("../types").ServiceProvider;
-}

package/types/services/cache-factory.d.ts

@@ -1,70 +1,3 @@
-/**
- * @ngdoc service
- * @name $cacheFactory
- *
- *
- * @description
- * Factory that constructs {@link $cacheFactory.Cache Cache} objects and gives access to
- * them.
- *
- * ```js
- *
- *  let cache = $cacheFactory('cacheId');
- *  expect($cacheFactory.get('cacheId')).toBe(cache);
- *  expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined();
- *
- *  cache.put("key", "value");
- *  cache.put("another key", "another value");
- *
- *  // We've specified no options on creation
- *  expect(cache.info()).toEqual({id: 'cacheId', size: 2});
- *
- * ```
- *
- *
- * @example
-   <example module="cacheExampleApp" name="cache-factory">
-     <file name="index.html">
-       <div ng-controller="CacheController">
-         <input ng-model="newCacheKey" placeholder="Key">
-         <input ng-model="newCacheValue" placeholder="Value">
-         <button ng-click="put(newCacheKey, newCacheValue)">Cache</button>
-
-         <p ng-if="keys.length">Cached Values</p>
-         <div ng-repeat="key in keys">
-           <span ng-bind="key"></span>
-           <span>: </span>
-           <b ng-bind="cache.get(key)"></b>
-         </div>
-
-         <p>Cache Info</p>
-         <div ng-repeat="(key, value) in cache.info()">
-           <span ng-bind="key"></span>
-           <span>: </span>
-           <b ng-bind="value"></b>
-         </div>
-       </div>
-     </file>
-     <file name="script.js">
-       angular.module('cacheExampleApp', []).
-         controller('CacheController', ['$scope', '$cacheFactory', function($scope, $cacheFactory) {
-           $scope.keys = [];
-           $scope.cache = $cacheFactory('cacheId');
-           $scope.put = function(key, value) {
-             if (angular.isUndefined($scope.cache.get(key))) {
-               $scope.keys.push(key);
-             }
-             $scope.cache.put(key, angular.isUndefined(value) ? null : value);
-           };
-         }]);
-     </file>
-     <file name="style.css">
-       p {
-         margin: 10px 0 3px;
-       }
-     </file>
-   </example>
- */
 export function CacheFactoryProvider(): void;
 export class CacheFactoryProvider {
     $get: () => {

package/types/services/cookie-reader.d.ts

@@ -1,12 +1,4 @@
 /**
- *
- * @description
- * This is a private service for reading cookies used by $http and ngCookies
- *
- * @return {Object} a key/value map of the current cookies
+ * @returns {Object<String, String>} List of all cookies
  */
-export function $$CookieReader(): any;
-export function CookieReaderProvider(): void;
-export class CookieReaderProvider {
-    $get: typeof $$CookieReader;
-}
+export function getCookies(): any;