@angular-wave/angular.ts 0.7.7 → 0.8.0

package/@types/router/{common → glob}/glob.d.ts

@@ -73,5 +73,9 @@ export class Glob {
    * @type {RegExp}
    */
   regexp: RegExp;
-  matches(name: any): boolean;
+  /**
+   * @param {string} name
+   * @return {boolean}
+   */
+  matches(name: string): boolean;
 }

package/@types/router/globals.d.ts

@@ -4,9 +4,8 @@
  *
  * This is where we hold the global mutable state such as current state, current
  * params, current transition, etc.
- * @implements {ServiceProvider}
  */
-export class RouterGlobals implements ServiceProvider {
+export class RouterGlobals {
   /**
    * Current parameter values
    *
@@ -45,4 +44,4 @@ export class RouterGlobals implements ServiceProvider {
  */
 export type ServiceProvider = import("../interface.ts").ServiceProvider;
 import { StateParams } from "./params/state-params.js";
-import { Queue } from "./common/queue.js";
+import { Queue } from "../shared/queue.js";

package/@types/router/path/path-utils.d.ts

@@ -34,19 +34,16 @@ export class PathUtils {
   static inheritParams(fromPath: any, toPath: any, toKeys?: any[]): any;
   /**
    * Computes the tree changes (entering, exiting) between a fromPath and toPath.
+   * @param {PathNode[]} fromPath
+   * @param {PathNode[]} toPath
+   * @param {boolean} [reloadState]
+   * @returns {import("../transition/interface.js").TreeChanges}
    */
   static treeChanges(
-    fromPath: any,
-    toPath: any,
-    reloadState: any,
-  ): {
-    from: any;
-    to: any;
-    retained: any;
-    retainedWithToParams: any;
-    exiting: any;
-    entering: any;
-  };
+    fromPath: PathNode[],
+    toPath: PathNode[],
+    reloadState?: boolean,
+  ): import("../transition/interface.js").TreeChanges;
   /**
    * Returns a new path which is: the subpath of the first path which matches the second path.
    *

package/@types/router/state/interface.d.ts

@@ -589,7 +589,7 @@ export interface StateDeclaration {
    *
    * An optional object which defines multiple views, or explicitly targets specific named ui-views.
    *
-   * - What is a view config
+   * - What is a view urlConfig
    * - What is a ui-view
    * - Shorthand controller/template
    * - Incompatible with ^

package/@types/router/state/state-object.d.ts

@@ -80,4 +80,4 @@ export namespace StateObject {
   function isState(obj: any): boolean;
 }
 export type StateDeclaration = import("./interface.js").StateDeclaration;
-import { Glob } from "../common/glob.js";
+import { Glob } from "../glob/glob.js";

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

@@ -4,9 +4,8 @@
  *
  * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
  *
- * @implements {ServiceProvider}
  */
-export class StateRegistryProvider implements ServiceProvider {
+export class StateRegistryProvider {
   static $inject: string[];
   /**
    * @param urlService

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

@@ -76,9 +76,9 @@ export class StateProvider {
    * - **params** `{object}` - returns an array of state params that are ensured to
    *   be a super-set of parent's params.
    * - **views** `{object}` - returns a views object where each key is an absolute view
-   *   name (i.e. "viewName@stateName") and each value is the config object
+   *   name (i.e. "viewName@stateName") and each value is the urlConfig object
    *   (template, controller) for the view. Even when you don't use the views object
-   *   explicitly on a state config, one is still created for you internally.
+   *   explicitly on a state urlConfig, one is still created for you internally.
    *   So by decorating this builder function you have access to decorating template
    *   and controller properties.
    * - **ownParams** `{object}` - returns an array of params that belong to the state,
@@ -96,10 +96,10 @@ export class StateProvider {
    *   let result = {},
    *       views = parent(state);
    *
-   *   angular.forEach(views, function (config, name) {
+   *   angular.forEach(views, function (urlConfig, name) {
    *     let autoName = (state.name + '.' + name).replace('.', '/');
-   *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
-   *     result[name] = config;
+   *     urlConfig.templateUrl = urlConfig.templateUrl || '/partials/' + autoName + '.html';
+   *     result[name] = urlConfig;
    *   });
    *   return result;
    * });
@@ -123,7 +123,7 @@ export class StateProvider {
    * @param {object} func A function that is responsible for decorating the original
    * builder function. The function receives two parameters:
    *
-   *   - `{object}` - state - The state config object.
+   *   - `{object}` - state - The state urlConfig object.
    *   - `{object}` - super - The original builder function.
    *
    * @return {object} $stateProvider - $stateProvider instance
@@ -265,7 +265,7 @@ export class StateProvider {
    * This may be returned from a Transition Hook to redirect a transition, for example.
    */
   target(identifier: any, params: any, options?: {}): TargetState;
-  getCurrentPath(): any;
+  getCurrentPath(): PathNode[];
   /**
    * Low-level method for transitioning to a new state.
    *
@@ -419,3 +419,4 @@ export class StateProvider {
   lazyLoad(stateOrName: any, transition: any): any;
 }
 import { TargetState } from "./target-state.js";
+import { PathNode } from "../path/path-node.js";

package/@types/router/state-filters.d.ts

@@ -1,15 +1,37 @@
 /**
+ * `isState` Filter: truthy if the current state is the parameter
+ *
+ * Translates to [[StateService.is]] `$state.is("stateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'stateName' | isState">show if state is 'stateName'</div>
+ * ```
+ *
+ * @param {import('./state/state-service.js').StateProvider} $state
  * @returns {import('../interface.ts').FilterFn}
  */
-export function $IsStateFilter($state: any): import("../interface.ts").FilterFn;
+export function $IsStateFilter(
+  $state: import("./state/state-service.js").StateProvider,
+): import("../interface.ts").FilterFn;
 export namespace $IsStateFilter {
   let $inject: string[];
 }
 /**
+ * `includedByState` Filter: truthy if the current state includes the parameter
+ *
+ * Translates to [[StateService.includes]]` $state.is("fullOrPartialStateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'fullOrPartialStateName' | includedByState">show if state includes 'fullOrPartialStateName'</div>
+ * ```
+ *
+ * @param {import('./state/state-service.js').StateProvider} $state
  * @returns {import('../interface.ts').FilterFn}
  */
 export function $IncludedByStateFilter(
-  $state: any,
+  $state: import("./state/state-service.js").StateProvider,
 ): import("../interface.ts").FilterFn;
 export namespace $IncludedByStateFilter {
   let $inject_1: string[];

package/@types/router/transition/transition.d.ts

@@ -14,15 +14,15 @@ export class Transition implements IHookRegistry {
    *
    * If the target state is not valid, an error is thrown.
    *
-   * @param fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
+   * @param {Array<import('../path/path-node.js').PathNode>} fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
    *        encapsulates the "from state".
-   * @param targetState The target state and parameters being transitioned to (also, the transition options)
+   * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
    * @param {import('../transition/transition-service.js').TransitionProvider} transitionService The [[TransitionService]] instance
    * @param {import('../globals.js').RouterGlobals} globals
    */
   constructor(
-    fromPath: any,
-    targetState: any,
+    fromPath: Array<import("../path/path-node.js").PathNode>,
+    targetState: import("../state/target-state.js").TargetState,
     transitionService: import("../transition/transition-service.js").TransitionProvider,
     globals: import("../globals.js").RouterGlobals,
   );
@@ -44,17 +44,10 @@ export class Transition implements IHookRegistry {
   _hookBuilder: HookBuilder;
   /** Checks if this transition is currently active/running. */
   isActive: () => boolean;
-  _targetState: any;
+  _targetState: import("../state/target-state.js").TargetState;
   _options: any;
   $id: number;
-  _treeChanges: {
-    from: any;
-    to: any;
-    retained: any;
-    retainedWithToParams: any;
-    exiting: any;
-    entering: any;
-  };
+  _treeChanges: import("./interface.js").TreeChanges;
   onStart: any;
   onBefore: any;
   onSuccess: any;
@@ -101,7 +94,7 @@ export class Transition implements IHookRegistry {
    *
    * @returns the [[TargetState]] of this Transition
    */
-  targetState(): any;
+  targetState(): import("../state/target-state.js").TargetState;
   /**
    * Determines whether two transitions are equivalent.
    * @deprecated
@@ -319,7 +312,11 @@ export class Transition implements IHookRegistry {
    * @returns a list of ViewConfig objects for the given path.
    */
   views(pathname: string, state: any): any;
-  treeChanges(pathname: any): any;
+  treeChanges(
+    pathname: any,
+  ):
+    | import("../path/path-node.js").PathNode[]
+    | import("./interface.js").TreeChanges;
   /**
    * Creates a new transition that is a redirection of the current one.
    *

package/@types/router/url/url-matcher.d.ts

@@ -112,9 +112,9 @@ export class UrlMatcher {
    * // returns { id: 'bob', q: 'hello', r: null }
    * ```
    *
-   * @param path    The URL path to match, e.g. `$location.path()`.
-   * @param search  URL search parameters, e.g. `$location.search()`.
-   * @param hash    URL hash e.g. `$location.hash()`.
+   * @param path    The URL path to match, e.g. `$location.getPath()`.
+   * @param search  URL search parameters, e.g. `$location.getSearch()`.
+   * @param hash    URL hash e.g. `$location.getHash()`.
    *
    * @returns The captured parameter values.
    */

package/@types/router/url/url-rule.d.ts

@@ -142,6 +142,7 @@ export class BaseUrlRule {
   $id: number;
   _group: any;
   handler: any;
+  priority: any;
   /**
    * This function should be overridden
    * @param {*} [params]

package/@types/router/url/url-rules.d.ts

@@ -6,14 +6,15 @@
  *
  * The most commonly used methods are [[otherwise]] and [[when]].
  *
- * This API is found at `$urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
+ * This API is found at `$url.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
  */
 export class UrlRules {
-  constructor(urlRuleFactory: any);
-  _sortFn: any;
+  /** @param {UrlRuleFactory} urlRuleFactory */
+  constructor(urlRuleFactory: UrlRuleFactory);
+  _sortFn: typeof defaultRuleSortFn;
   _rules: any[];
   _id: number;
-  urlRuleFactory: any;
+  urlRuleFactory: UrlRuleFactory;
   /**
    * Defines the initial state, path, or behavior to use when the app starts.
    *
@@ -94,7 +95,7 @@ export class UrlRules {
    * @param handler The url path to redirect to, or a function which returns the url path (or performs custom logic).
    */
   otherwise(handler: any): void;
-  _otherwiseFn: any;
+  _otherwiseFn: import("./url-rule.js").BaseUrlRule;
   _sorted: boolean;
   /**
    * Remove a rule previously registered
@@ -225,5 +226,24 @@ export class UrlRules {
    *
    * @return the registered [[UrlRule]]
    */
-  when(matcher: any, handler: any, options: any): any;
+  when(
+    matcher: any,
+    handler: any,
+    options: any,
+  ): import("./url-rule.js").BaseUrlRule;
 }
+/**
+ * Default rule priority sorting function.
+ *
+ * Sorts rules by:
+ *
+ * - Explicit priority (set rule priority using [[UrlRules.when]])
+ * - Rule type (STATE: 4, URLMATCHER: 4, REGEXP: 3, RAW: 2, OTHER: 1)
+ * - `UrlMatcher` specificity ([[UrlMatcher.compare]]): works for STATE and URLMATCHER types to pick the most specific rule.
+ * - Rule registration order (for rule types other than STATE and URLMATCHER)
+ *   - Equally sorted State and UrlMatcher rules will each match the URL.
+ *     Then, the *best* match is chosen based on how many parameter values were matched.
+ */
+declare function defaultRuleSortFn(a: any, b: any): number;
+import { UrlRuleFactory } from "./url-rule.js";
+export {};

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

@@ -4,76 +4,70 @@
 export class UrlService {
   static $inject: string[];
   /**
-   * @param {import("../../core/location/location").LocationProvider} $locationProvider
+   * @param {import("../../services/location/location").LocationProvider} $locationProvider
    * @param {import("../../router/state/state-service.js").StateProvider} stateService
-   * @param globals
+   * @param {import("../../router/globals.js").RouterGlobals} globals
    * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
    */
   constructor(
     $locationProvider: any,
     stateService: import("../../router/state/state-service.js").StateProvider,
-    globals: any,
+    globals: import("../../router/globals.js").RouterGlobals,
     urlConfigProvider: import("../../router/url/url-config.js").UrlConfigProvider,
   );
-  stateService: import("../../router/state/state-service.js").StateProvider;
+  /** @type {import("../../services/location/location").Location} */
+  $location: any;
   $locationProvider: any;
-  $location: import("../../core/location/location.js").Location;
-  $browser: import("../../services/browser.js").Browser;
+  stateService: import("../../router/state/state-service.js").StateProvider;
   /** Provides services related to the URL */
   urlRuleFactory: UrlRuleFactory;
   /**
    * The nested [[UrlRules]] API for managing URL rules and rewrites
-   *
-   * See: [[UrlRules]] for details
    * @type {UrlRules}
    */
   rules: UrlRules;
   /**
    * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
-   *
-   * See: [[UrlConfig]] for details
    * @type {import("./url-config.js").UrlConfigProvider}
    */
   config: import("./url-config.js").UrlConfigProvider;
   /** Creates a new [[Param]] for a given location (DefType) */
   paramFactory: ParamFactory;
+  _urlListeners: any[];
   /**
    * Gets the path part of the current url
    *
    * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
    *
-   * @return the path portion of the url
+   * @return {string} the path portion of the url
    */
-  path: () => any;
+  getPath(): string;
   /**
    * Gets the search part of the current url as an object
    *
    * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
    *
-   * @return the search (query) portion of the url, as an object
+   * @return {Object} the search (query) portion of the url, as an object
    */
-  search: () => any;
+  getSearch(): any;
   /**
    * Gets the hash part of the current url
    *
    * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
    *
-   * @return the hash (anchor) portion of the url
+   * @return {string} the hash (anchor) portion of the url
    */
-  hash: () => string | import("../../core/location/location.js").Location;
-  _urlListeners: any[];
+  getHash(): string;
   $get: (
     | string
     | ((
-        $location: import("../../core/location/location.js").Location,
-        $browser: import("../../services/browser.js").Browser,
+        $location: import("../../services/location/location.js").Location,
         $rootScope: import("../../core/scope/scope.js").Scope,
       ) => UrlService)
   )[];
   /**
-   * @returns {boolean}
+   * @returns {string}
    */
-  html5Mode(): boolean;
   baseHref(): string;
   _baseHref: string;
   /**
@@ -123,18 +117,13 @@ export class UrlService {
    * @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)
    *
    * @return the url (after potentially being processed)
    */
-  url(
-    newUrl?: string,
-    replace?: boolean,
-    state?: any,
-  ): string | import("../../core/location/location.js").Location;
+  url(newUrl?: string, state?: any): any;
   /**
-   * @internal
+   * @private
    *
    * Registers a low level url change handler
    *
@@ -145,20 +134,19 @@ export class UrlService {
    * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
    * ```
    *
-   * @param callback a function that will be called when the url is changing
-   * @return a function that de-registers the callback
+   * @param {Function} callback a function that will be called when the url is changing
+   * @return {Function} a function that de-registers the callback
    */
-  onChange(callback: any): () => any;
+  private onChange;
   /**
-   * Gets the current URL parts
+   * Gets the current URL parts.
+   *
+   * Returns an object with the `path`, `search`, and `hash` components
+   * of the current browser location.
    *
-   * This method returns the different parts of the current URL (the [[path]], [[search]], and [[hash]]) as a [[UrlParts]] object.
+   * @returns {import("../../services/location/interface.ts").UrlParts} The current URL's path, search, and hash.
    */
-  parts(): {
-    path: any;
-    search: any;
-    hash: string | import("../../core/location/location.js").Location;
-  };
+  parts(): import("../../services/location/interface.ts").UrlParts;
   /**
    * Activates the best rule for the current URL
    *
@@ -198,9 +186,9 @@ export class UrlService {
    * });
    * ```
    *
-   * @param enabled `true` or `false` to start or stop listening to URL changes
+   * @param {boolean} enabled `true` or `false` to start or stop listening to URL changes
    */
-  listen(enabled: any): any;
+  listen(enabled: boolean): any;
   _stopListeningFn: any;
   /**
    * Matches a URL
@@ -211,7 +199,7 @@ export class UrlService {
    */
   match(url: any): any;
   update(read: any): void;
-  location: string | import("../../core/location/location.js").Location;
+  location: any;
   /**
    * Internal API.
    *
@@ -230,7 +218,7 @@ export class UrlService {
    * ```js
    * matcher = $umf.compile("/about/:person");
    * params = { person: "bob" };
-   * $bob = $urlService.href(matcher, params);
+   * $bob = $url.href(matcher, params);
    * // $bob == "/about/bob";
    * ```
    *

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

@@ -13,7 +13,7 @@ export class AnchorScrollProvider {
   $get: (
     | string
     | ((
-        $location: import("../core/location/location.js").Location,
+        $location: import("../services/location/location.js").Location,
         $rootScope: import("../core/scope/scope.js").Scope,
       ) => AnchorScrollFunction)
   )[];

package/@types/{core → services/exception}/exception-handler.d.ts

@@ -41,8 +41,8 @@
  *
  * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
-/** @typedef {import('../services/log/interface.ts').LogService} LogService */
-/** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
+/** @typedef {import('../log/interface.ts').LogService} LogService */
+/** @typedef {import("./interface.ts").Interface}  ErrorHandler */
 /**
  * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
  * Can be overridden to implement custom error-handling logic.
@@ -54,5 +54,5 @@ export class ExceptionHandlerProvider {
   errorHandler: ErrorHandler;
   $get: (string | (($log: LogService) => ErrorHandler))[];
 }
-export type LogService = import("../services/log/interface.ts").LogService;
-export type ErrorHandler = import("./error-handler.ts").ErrorHandler;
+export type LogService = import("../log/interface.ts").LogService;
+export type ErrorHandler = import("./interface.ts").Interface;

package/@types/{core/error-handler.d.ts → services/exception/interface.d.ts}

@@ -4,4 +4,4 @@
  * @param exception - The exception associated with the error.
  * @param [cause] - Optional information about the context in which the error was thrown.
  */
-export type ErrorHandler = (exception: Error, cause?: string) => void;
+export type Interface = (exception: Error, cause?: string) => void;

package/@types/services/http/http.d.ts

@@ -50,14 +50,59 @@ export class HttpProvider {
    *    otherwise, returns the current configured value.
    */
   useApplyAsync: (value?: boolean | undefined) => boolean | any;
+  /**
+   * Array containing service factories for all synchronous or asynchronous {@link ng.$http $http}
+   * pre-processing of request or postprocessing of responses.
+   *
+   * These service factories are ordered by request, i.e. they are applied in the same order as the
+   * array, on request, but reverse order, on response.
+   *
+   * {@link ng.$http#interceptors Interceptors detailed info}
+   */
   interceptors: any[];
-  xsrfTrustedOrigins: any[];
+  /**
+   * Array containing URLs whose origins are trusted to receive the XSRF token. See the
+   * {@link ng.$http#security-considerations Security Considerations} sections for more details on
+   * XSRF.
+   *
+   * **Note:** An "origin" consists of the [URI scheme](https://en.wikipedia.org/wiki/URI_scheme),
+   * the [hostname](https://en.wikipedia.org/wiki/Hostname) and the
+   * [port number](https://en.wikipedia.org/wiki/Port_(computer_networking). For `http:` and
+   * `https:`, the port number can be omitted if using th default ports (80 and 443 respectively).
+   * Examples: `http://example.com`, `https://api.example.com:9876`
+   *
+   * <div class="alert alert-warning">
+   *   It is not possible to trust specific URLs/paths. The `path`, `query` and `fragment` parts
+   *   of a URL will be ignored. For example, `https://foo.com/path/bar?query=baz#fragment` will be
+   *   treated as `https://foo.com`, meaning that **all** requests to URLs starting with
+   *   `https://foo.com/` will include the XSRF token.
+   * </div>
+   *
+   * @example
+   *
+   * ```js
+   * // App served from `https://example.com/`.
+   * angular.
+   *   module('xsrfTrustedOriginsExample', []).
+   *   config(['$httpProvider', function($httpProvider) {
+   *     $httpProvider.xsrfTrustedOrigins.push('https://api.example.com');
+   *   }]).
+   *   run(['$http', function($http) {
+   *     // The XSRF token will be sent.
+   *     $http.get('https://api.example.com/preferences').then(...);
+   *
+   *     // The XSRF token will NOT be sent.
+   *     $http.get('https://stats.example.com/activity').then(...);
+   *   }]);
+   * ```
+   *
+   * @type {string[]}
+   */
+  xsrfTrustedOrigins: string[];
   $get: (
     | string
     | ((
-        $browser: any,
         $httpBackend: any,
-        $rootScope: import("../../core/scope/scope.js").Scope,
         $injector: import("../../core/di/internal-injector.js").InjectorService,
         $sce: any,
       ) => {

package/@types/services/http/interface.d.ts

@@ -126,14 +126,14 @@ export interface RequestConfig extends RequestShortcutConfig {
       }
     | undefined;
 }
+export type HttpResponseStatus = "complete" | "error" | "timeout" | "abort";
 export interface HttpResponse<T> {
   data: T;
   status: number;
   headers: HttpHeadersGetter;
   config: RequestConfig;
   statusText: string;
-  /** Added in AngularJS 1.6.6 */
-  xhrStatus: "complete" | "error" | "timeout" | "abort";
+  xhrStatus: HttpResponseStatus;
 }
 export type HttpPromise<T> = Promise<HttpResponse<T>>;
 /**