@angular-wave/angular.ts 0.7.8 → 0.8.0

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

@@ -1,4 +1,9 @@
-export function ParseProvider(): void;
+export function constantWatchDelegate(
+  scope: any,
+  listener: any,
+  objectEquality: any,
+  parsedExpression: any,
+): any;
 export class ParseProvider {
   /**
    * Allows defining the set of characters that are allowed in AngularTS expressions. The function
@@ -26,9 +31,3 @@ export class ParseProvider {
   ) => ParseProvider;
   $get: (string | (($filter: (any: any) => any) => any))[];
 }
-export function constantWatchDelegate(
-  scope: any,
-  listener: any,
-  objectEquality: any,
-  parsedExpression: any,
-): any;

package/@types/directive/bind/bind.d.ts

@@ -7,10 +7,11 @@ export function ngBindDirective(): import("../../interface.ts").Directive;
  */
 export function ngBindTemplateDirective(): import("../../interface.ts").Directive;
 /**
+ * @param {import('../../core/parse/interface.ts').ParseService} $parse
  * @returns {import('../../interface.ts').Directive}
  */
 export function ngBindHtmlDirective(
-  $parse: any,
+  $parse: import("../../core/parse/interface.ts").ParseService,
 ): import("../../interface.ts").Directive;
 export namespace ngBindHtmlDirective {
   let $inject: string[];

package/@types/index.d.ts

@@ -1,2 +1,2 @@
 export const angular: Angular;
-import { Angular } from "./loader.js";
+import { Angular } from "./angular.js";

package/@types/interface.d.ts

@@ -4,6 +4,8 @@ export * from "./core/di/ng-module.js";
 export * from "./services/http/interface.ts";
 export * from "./services/log/interface.ts";
 export * from "./services/log/log.js";
+export * from "./services/location/interface.ts";
+export * from "./services/location/location.js";
 export * from "./services/pubsub/pubsub.js";
 export * from "./services/template-cache/interface.ts";
 export * from "./services/template-cache/template-cache.js";
@@ -61,7 +63,7 @@ export interface Provider {
   /**
    * Register a directive
    * @param name - The name of the directive.
-   * @param provider - An object with a `$get` property that defines how the service is created.
+   * @param directive - An object with a `$get` property that defines how the service is created.
    */
   directive(name: string, directive: DirectiveFactory): Provider;
   /**

package/@types/{public.d.ts → ng.d.ts}

@@ -1,8 +1,8 @@
 /**
  * Initializes core `ng` module.
- * @param {import('./loader.js').Angular} angular
+ * @param {import('./angular.js').Angular} angular
  * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
  */
 export function registerNgModule(
-  angular: import("./loader.js").Angular,
+  angular: import("./angular.js").Angular,
 ): import("./core/di/ng-module.js").NgModule;

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

@@ -44,4 +44,4 @@ export class RouterGlobals {
  */
 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-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

@@ -6,61 +6,58 @@ export class UrlService {
   /**
    * @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("../../services/location/location.js").Location;
+  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("../../services/location/location.js").Location;
-  _urlListeners: any[];
+  getHash(): string;
   $get: (
     | string
     | ((
@@ -69,9 +66,8 @@ export class UrlService {
       ) => UrlService)
   )[];
   /**
-   * @returns {boolean}
+   * @returns {string}
    */
-  html5Mode(): boolean;
   baseHref(): string;
   _baseHref: string;
   /**
@@ -121,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("../../services/location/location.js").Location;
+  url(newUrl?: string, state?: any): any;
   /**
-   * @internal
+   * @private
    *
    * Registers a low level url change handler
    *
@@ -143,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("../../services/location/location.js").Location;
-  };
+  parts(): import("../../services/location/interface.ts").UrlParts;
   /**
    * Activates the best rule for the current URL
    *
@@ -196,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
@@ -209,7 +199,7 @@ export class UrlService {
    */
   match(url: any): any;
   update(read: any): void;
-  location: string | import("../../services/location/location.js").Location;
+  location: any;
   /**
    * Internal API.
    *
@@ -228,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/http/http.d.ts

@@ -50,8 +50,55 @@ 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
     | ((

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

@@ -2,44 +2,57 @@
  * @returns
  */
 export function createHttpBackend(): (
-  method: any,
-  url: any,
-  post: any,
-  callback: any,
-  headers: any,
-  timeout: any,
-  withCredentials: any,
-  responseType: any,
-  eventHandlers: any,
-  uploadEventHandlers: any,
+  method: string,
+  url?: string,
+  post?: any,
+  callback?: (
+    arg0: number,
+    arg1: any,
+    arg2: string | null,
+    arg3: string,
+    arg4: string,
+  ) => void,
+  headers?: {
+    [x: string]: string;
+  },
+  timeout?: number | Promise<any>,
+  withCredentials?: boolean,
+  responseType?: XMLHttpRequestResponseType,
+  eventHandlers?: {
+    [x: string]: EventListener;
+  },
+  uploadEventHandlers?: {
+    [x: string]: EventListener;
+  },
 ) => void;
 /**
- * HTTP backend used by the {@link ng.$http service} that delegates to
+ * HTTP backend used by the `$http` that delegates to
  * XMLHttpRequest object and deals with browser incompatibilities.
- *
- * You should never need to use this service directly, instead use the higher-level abstractions:
- * {@link ng.$http $http}.
- *
- */
-/**
- * HTTP backend used by the {@link ng.$http service} that delegates to
- * XMLHttpRequest object and deals with browser incompatibilities.
- *
- * You should never need to use this service directly, instead use the higher-level abstractions:
- * {@link ng.$http $http}.
- *
+ * You should never need to use this service directly.
  */
 export class HttpBackendProvider {
-  $get: (() => (
-    method: any,
-    url: any,
-    post: any,
-    callback: any,
-    headers: any,
-    timeout: any,
-    withCredentials: any,
-    responseType: any,
-    eventHandlers: any,
-    uploadEventHandlers: any,
-  ) => void)[];
+  $get: () => (
+    method: string,
+    url?: string,
+    post?: any,
+    callback?: (
+      arg0: number,
+      arg1: any,
+      arg2: string | null,
+      arg3: string,
+      arg4: string,
+    ) => void,
+    headers?: {
+      [x: string]: string;
+    },
+    timeout?: number | Promise<any>,
+    withCredentials?: boolean,
+    responseType?: XMLHttpRequestResponseType,
+    eventHandlers?: {
+      [x: string]: EventListener;
+    },
+    uploadEventHandlers?: {
+      [x: string]: EventListener;
+    },
+  ) => void;
 }