@angular-wave/angular.ts 0.7.8 → 0.8.1

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.js").Router} 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.js").Router,
     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;
 }

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

@@ -6,3 +6,58 @@
  * @returns void
  */
 export type UrlChangeListener = (url: string, state: History["state"]) => void;
+/**
+ * Represents the configuration options for HTML5 mode.
+ */
+export interface Html5Mode {
+  /**
+   * If true, will rely on `history.pushState` to change URLs where supported.
+   * Falls back to hash-prefixed paths in browsers that do not support `pushState`.
+   * @default false
+   */
+  enabled: boolean;
+  /**
+   * When html5Mode is enabled, specifies whether or not a `<base>` tag is required to be present.
+   * If both `enabled` and `requireBase` are true, and a `<base>` tag is not present,
+   * an error will be thrown when `$location` is injected.
+   * @default true
+   */
+  requireBase: boolean;
+  /**
+   * When html5Mode is enabled, enables or disables URL rewriting for relative links.
+   * If set to a string, URL rewriting will only apply to links with an attribute that matches the given string.
+   * For example, if set to `'internal-link'`, URL rewriting will only occur for `<a internal-link>` links.
+   * Attribute name normalization does not apply here.
+   * @default true
+   */
+  rewriteLinks: boolean | string;
+}
+/**
+ * Represents default port numbers for various protocols.
+ */
+export interface DefaultPorts {
+  http: number;
+  https: number;
+  ftp: number;
+}
+/**
+ * Represents the individual components of a URL.
+ */
+export interface UrlParts {
+  /**
+   * The URL path (e.g. `/dashboard`, `/users/123`).
+   */
+  path: string;
+  /**
+   * The parsed query string as an object.
+   * Mirrors AngularJS’s `$location.setSearch()` format.
+   */
+  search: Record<
+    string,
+    string | number | boolean | (string | number | boolean)[]
+  >;
+  /**
+   * The fragment identifier (everything after `#`, not including the `#` itself).
+   */
+  hash: string;
+}