@angular-wave/angular.ts 0.0.35 → 0.0.37

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

@@ -0,0 +1,146 @@
+/**
+ * Creates a [[UrlRule]]
+ *
+ * Creates a [[UrlRule]] from a:
+ *
+ * - `string`
+ * - [[UrlMatcher]]
+ * - `RegExp`
+ * - [[StateObject]]
+ */
+export class UrlRuleFactory {
+  constructor(urlService: any, stateService: any, routerGlobals: any);
+  urlService: any;
+  stateService: any;
+  routerGlobals: any;
+  /**
+   *
+   * @param {*} what
+   * @param {*} handler
+   * @returns {BaseUrlRule}
+   */
+  create(what: any, handler: any): BaseUrlRule;
+  /**
+   * A UrlRule which matches based on a UrlMatcher
+   *
+   * The `handler` may be either a `string`, a [[UrlRuleHandlerFn]] or another [[UrlMatcher]]
+   *
+   * ## Handler as a function
+   *
+   * If `handler` is a function, the function is invoked with:
+   *
+   * - matched parameter values ([[RawParams]] from [[UrlMatcher.exec]])
+   * - url: the current Url ([[UrlParts]])
+   * - router: the router object ([[UIRouter]])
+   *
+   * #### Example:
+   * ```js
+   * var urlMatcher = $umf.compile("/foo/:fooId/:barId");
+   * var rule = factory.fromUrlMatcher(urlMatcher, match => "/home/" + match.fooId + "/" + match.barId);
+   * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }
+   * var result = rule.handler(match); // '/home/123/456'
+   * ```
+   *
+   * ## Handler as UrlMatcher
+   *
+   * If `handler` is a UrlMatcher, the handler matcher is used to create the new url.
+   * The `handler` UrlMatcher is formatted using the matched param from the first matcher.
+   * The url is replaced with the result.
+   *
+   * #### Example:
+   * ```js
+   * var urlMatcher = $umf.compile("/foo/:fooId/:barId");
+   * var handler = $umf.compile("/home/:fooId/:barId");
+   * var rule = factory.fromUrlMatcher(urlMatcher, handler);
+   * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }
+   * var result = rule.handler(match); // '/home/123/456'
+   * ```
+   */
+  fromUrlMatcher(
+    urlMatcher: any,
+    handler: any,
+  ): BaseUrlRule & {
+    urlMatcher: any;
+    matchPriority: (params: any) => number;
+    type: string;
+  };
+  /**
+   * A UrlRule which matches a state by its url
+   *
+   * #### Example:
+   * ```js
+   * var rule = factory.fromState($state.get('foo'), router);
+   * var match = rule.match('/foo/123/456'); // results in { fooId: '123', barId: '456' }
+   * var result = rule.handler(match);
+   * // Starts a transition to 'foo' with params: { fooId: '123', barId: '456' }
+   * ```
+   */
+  fromState(
+    stateOrDecl: any,
+    stateService: any,
+    globals: any,
+  ): BaseUrlRule & {
+    urlMatcher: any;
+    matchPriority: (params: any) => number;
+    type: string;
+  } & {
+    state: any;
+    type: string;
+  };
+  /**
+   * A UrlRule which matches based on a regular expression
+   *
+   * The `handler` may be either a [[UrlRuleHandlerFn]] or a string.
+   *
+   * ## Handler as a function
+   *
+   * If `handler` is a function, the function is invoked with:
+   *
+   * - regexp match array (from `regexp`)
+   * - url: the current Url ([[UrlParts]])
+   * - router: the router object ([[UIRouter]])
+   *
+   * #### Example:
+   * ```js
+   * var rule = factory.fromRegExp(/^\/foo\/(bar|baz)$/, match => "/home/" + match[1])
+   * var match = rule.match('/foo/bar'); // results in [ '/foo/bar', 'bar' ]
+   * var result = rule.handler(match); // '/home/bar'
+   * ```
+   *
+   * ## Handler as string
+   *
+   * If `handler` is a string, the url is *replaced by the string* when the Rule is invoked.
+   * The string is first interpolated using `string.replace()` style pattern.
+   *
+   * #### Example:
+   * ```js
+   * var rule = factory.fromRegExp(/^\/foo\/(bar|baz)$/, "/home/$1")
+   * var match = rule.match('/foo/bar'); // results in [ '/foo/bar', 'bar' ]
+   * var result = rule.handler(match); // '/home/bar'
+   * ```
+   */
+  fromRegExp(
+    regexp: any,
+    handler: any,
+  ): BaseUrlRule & {
+    regexp: any;
+    type: string;
+  };
+}
+export namespace UrlRuleFactory {
+  function isUrlRule(obj: any): boolean;
+}
+/**
+ * A base rule which calls `match`
+ *
+ * The value from the `match` function is passed through to the `handler`.
+ * @type {angular.BaseUrlRule}
+ */
+export class BaseUrlRule {
+  constructor(match: any, handler: any);
+  match: any;
+  type: string;
+  $id: number;
+  matchPriority: () => number;
+  handler: any;
+}

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

@@ -0,0 +1,229 @@
+/**
+ * API for managing URL rules
+ *
+ * This API is used to create and manage URL rules.
+ * URL rules are a mechanism to respond to specific URL patterns.
+ *
+ * The most commonly used methods are [[otherwise]] and [[when]].
+ *
+ * This API is found at `$urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
+ */
+export class UrlRules {
+  constructor(urlRuleFactory: any);
+  _sortFn: any;
+  _rules: any[];
+  _id: number;
+  urlRuleFactory: any;
+  /**
+   * Defines the initial state, path, or behavior to use when the app starts.
+   *
+   * This rule defines the initial/starting state for the application.
+   *
+   * This rule is triggered the first time the URL is checked (when the app initially loads).
+   * The rule is triggered only when the url matches either `""` or `"/"`.
+   *
+   * Note: The rule is intended to be used when the root of the application is directly linked to.
+   * When the URL is *not* `""` or `"/"` and doesn't match other rules, the [[otherwise]] rule is triggered.
+   * This allows 404-like behavior when an unknown URL is deep-linked.
+   *
+   * #### Example:
+   * Start app at `home` state.
+   * ```js
+   * .initial({ state: 'home' });
+   * ```
+   *
+   * #### Example:
+   * Start app at `/home` (by url)
+   * ```js
+   * .initial('/home');
+   * ```
+   *
+   * #### Example:
+   * When no other url rule matches, go to `home` state
+   * ```js
+   * .initial((matchValue, url, router) => {
+   *   console.log('initial state');
+   *   return { state: 'home' };
+   * })
+   * ```
+   *
+   * @param handler The initial state or url path, or a function which returns the state or url path (or performs custom logic).
+   */
+  initial(handler: any): void;
+  /**
+   * Defines the state, url, or behavior to use when no other rule matches the URL.
+   *
+   * This rule is matched when *no other rule* matches.
+   * It is generally used to handle unknown URLs (similar to "404" behavior, but on the client side).
+   *
+   * - If `handler` a string, it is treated as a url redirect
+   *
+   * #### Example:
+   * When no other url rule matches, redirect to `/index`
+   * ```js
+   * .otherwise('/index');
+   * ```
+   *
+   * - If `handler` is an object with a `state` property, the state is activated.
+   *
+   * #### Example:
+   * When no other url rule matches, redirect to `home` and provide a `dashboard` parameter value.
+   * ```js
+   * .otherwise({ state: 'home', params: { dashboard: 'default' } });
+   * ```
+   *
+   * - If `handler` is a function, the function receives the current url ([[UrlParts]]) and the [[UIRouter]] object.
+   *   The function can perform actions, and/or return a value.
+   *
+   * #### Example:
+   * When no other url rule matches, manually trigger a transition to the `home` state
+   * ```js
+   * .otherwise((matchValue, urlParts, router) => {
+   *   router.stateService.go('home');
+   * });
+   * ```
+   *
+   * #### Example:
+   * When no other url rule matches, go to `home` state
+   * ```js
+   * .otherwise((matchValue, urlParts, router) => {
+   *   return { state: 'home' };
+   * });
+   * ```
+   *
+   * @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;
+  _sorted: boolean;
+  /**
+   * Remove a rule previously registered
+   *
+   * @param rule the matcher rule that was previously registered using [[rule]]
+   */
+  removeRule(rule: any): void;
+  /**
+   * Manually adds a URL Rule.
+   *
+   * Usually, a url rule is added using [[StateDeclaration.url]] or [[when]].
+   * This api can be used directly for more control (to register a [[BaseUrlRule]], for example).
+   * Rules can be created using [[urlRuleFactory]], or created manually as simple objects.
+   *
+   * A rule should have a `match` function which returns truthy if the rule matched.
+   * It should also have a `handler` function which is invoked if the rule is the best match.
+   *
+   * @return a function that deregisters the rule
+   */
+  rule(rule: any): () => void;
+  /**
+   * Gets all registered rules
+   *
+   * @returns an array of all the registered rules
+   */
+  rules(): any[];
+  /**
+   * Defines URL Rule priorities
+   *
+   * More than one rule ([[UrlRule]]) might match a given URL.
+   * This `compareFn` is used to sort the rules by priority.
+   * Higher priority rules should sort earlier.
+   *
+   * The [[defaultRuleSortFn]] is used by default.
+   *
+   * You only need to call this function once.
+   * The `compareFn` will be used to sort the rules as each is registered.
+   *
+   * If called without any parameter, it will re-sort the rules.
+   *
+   * ---
+   *
+   * Url rules may come from multiple sources: states's urls ([[StateDeclaration.url]]), [[when]], and [[rule]].
+   * Each rule has a (user-provided) [[UrlRule.priority]], a [[UrlRule.type]], and a [[UrlRule.$id]]
+   * The `$id` is is the order in which the rule was registered.
+   *
+   * The sort function should use these data, or data found on a specific type
+   * of [[UrlRule]] (such as [[StateRule.state]]), to order the rules as desired.
+   *
+   * #### Example:
+   * This compare function prioritizes rules by the order in which the rules were registered.
+   * A rule registered earlier has higher priority.
+   *
+   * ```js
+   * function compareFn(a, b) {
+   *   return a.$id - b.$id;
+   * }
+   * ```
+   *
+   * @param compareFn a function that compares to [[UrlRule]] objects.
+   *    The `compareFn` should abide by the `Array.sort` compare function rules.
+   *    Given two rules, `a` and `b`, return a negative number if `a` should be higher priority.
+   *    Return a positive number if `b` should be higher priority.
+   *    Return `0` if the rules are identical.
+   *
+   *    See the [mozilla reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Description)
+   *    for details.
+   */
+  sort(compareFn: any): void;
+  ensureSorted(): void;
+  stableSort(arr: any, compareFn: any): any;
+  /**
+   * Registers a `matcher` and `handler` for custom URLs handling.
+   *
+   * The `matcher` can be:
+   *
+   * - a [[UrlMatcher]]: See: [[UrlMatcherFactory.compile]]
+   * - a `string`: The string is compiled to a [[UrlMatcher]]
+   * - a `RegExp`: The regexp is used to match the url.
+   *
+   * The `handler` can be:
+   *
+   * - a string: The url is redirected to the value of the string.
+   * - a function: The url is redirected to the return value of the function.
+   *
+   * ---
+   *
+   * When the `handler` is a `string` and the `matcher` is a `UrlMatcher` (or string), the redirect
+   * string is interpolated with parameter values.
+   *
+   * #### Example:
+   * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
+   * ```js
+   * .when("/foo/:param1", "/bar/:param1")
+   * ```
+   *
+   * ---
+   *
+   * When the `handler` is a string and the `matcher` is a `RegExp`, the redirect string is
+   * interpolated with capture groups from the RegExp.
+   *
+   * #### Example:
+   * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
+   * ```js
+   * .when(new RegExp("^/foo/(.*)$"), "/bar/$1");
+   * ```
+   *
+   * ---
+   *
+   * When the handler is a function, it receives the matched value, the current URL, and the `UIRouter` object (See [[UrlRuleHandlerFn]]).
+   * The "matched value" differs based on the `matcher`.
+   * For [[UrlMatcher]]s, it will be the matched state params.
+   * For `RegExp`, it will be the match array from `regexp.exec()`.
+   *
+   * If the handler returns a string, the URL is redirected to the string.
+   *
+   * #### Example:
+   * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
+   * ```js
+   * .when(new RegExp("^/foo/(.*)$"), match => "/bar/" + match[1]);
+   * ```
+   *
+   * Note: the `handler` may also invoke arbitrary code, such as `$state.go()`
+   *
+   * @param matcher A pattern `string` to match, compiled as a [[UrlMatcher]], or a `RegExp`.
+   * @param handler The path to redirect to, or a function that returns the path.
+   * @param options `{ priority: number }`
+   *
+   * @return the registered [[UrlRule]]
+   */
+  when(matcher: any, handler: any, options: any): any;
+}

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

@@ -0,0 +1,278 @@
+/**
+ * API for URL management
+ */
+export class UrlService {
+  static $inject: string[];
+  /**
+   * @param {angular.ILocationProvider} $locationProvider
+   */
+  constructor(
+    $locationProvider: angular.ILocationProvider,
+    stateService: any,
+    globals: any,
+    urlConfigProvider: any,
+  );
+  stateService: any;
+  $locationProvider: angular.ILocationProvider;
+  $location: any;
+  $browser: any;
+  /** @type {boolean} */
+  interceptDeferred: boolean;
+  /** 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 {angular.UrlConfig}
+   */
+  config: angular.UrlConfig;
+  /** Creates a new [[Param]] for a given location (DefType) */
+  paramFactory: ParamFactory;
+  /**
+   * 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
+   */
+  path: () => any;
+  /**
+   * 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
+   */
+  search: () => 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
+   */
+  hash: () => any;
+  _urlListeners: any[];
+  $get: (string | (($location: any, $browser: any, $rootScope: any) => this))[];
+  html5Mode(): boolean;
+  baseHref(): any;
+  _baseHref: any;
+  /**
+   * Gets the current url, or updates the url
+   *
+   * ### Getting the current URL
+   *
+   * When no arguments are passed, returns the current URL.
+   * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.
+   *
+   * For example, the URL may be stored in the hash ([[HashLocationServices]]) or
+   * have a base HREF prepended ([[PushStateLocationServices]]).
+   *
+   * The raw URL in the browser might be:
+   *
+   * ```
+   * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor
+   * ```
+   *
+   * or
+   *
+   * ```
+   * http://mysite.com/basepath/internal/path/123?param1=foo#anchor
+   * ```
+   *
+   * then this method returns:
+   *
+   * ```
+   * /internal/path/123?param1=foo#anchor
+   * ```
+   *
+   *
+   * #### Example:
+   * ```js
+   * locationServices.url(); // "/some/path?query=value#anchor"
+   * ```
+   *
+   * ### Updating the URL
+   *
+   * When `newurl` arguments is provided, changes the URL to reflect `newurl`
+   *
+   * #### Example:
+   * ```js
+   * locationServices.url("/some/path?query=value#anchor", true);
+   * ```
+   *
+   * @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): any;
+  /**
+   * @internal
+   *
+   * Registers a low level url change handler
+   *
+   * Note: Because this is a low level handler, it's not recommended for general use.
+   *
+   * #### Example:
+   * ```js
+   * 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
+   */
+  onChange(callback: any): () => any;
+  /**
+   * Gets the current URL parts
+   *
+   * This method returns the different parts of the current URL (the [[path]], [[search]], and [[hash]]) as a [[UrlParts]] object.
+   */
+  parts(): {
+    path: any;
+    search: any;
+    hash: any;
+  };
+  /**
+   * Activates the best rule for the current URL
+   *
+   * Checks the current URL for a matching [[UrlRule]], then invokes that rule's handler.
+   * This method is called internally any time the URL has changed.
+   *
+   * This effectively activates the state (or redirect, etc) which matches the current URL.
+   *
+   * #### Example:
+   * ```js
+   * urlService.deferIntercept();
+   *
+   * fetch('/states.json').then(resp => resp.json()).then(data => {
+   *   data.forEach(state => $stateRegistry.register(state));
+   *   urlService.listen();
+   *   // Find the matching URL and invoke the handler.
+   *   urlService.sync();
+   * });
+   * ```
+   */
+  sync(evt: any): void;
+  /**
+   * Starts or stops listening for URL changes
+   *
+   * Call this sometime after calling [[deferIntercept]] to start monitoring the url.
+   * This causes ng-router to start listening for changes to the URL, if it wasn't already listening.
+   *
+   * If called with `false`, ng-router will stop listening (call listen(true) to start listening again).
+   *
+   * #### Example:
+   * ```js
+   * urlService.deferIntercept();
+   *
+   * fetch('/states.json').then(resp => resp.json()).then(data => {
+   *   data.forEach(state => $stateRegistry.register(state));
+   *   // Start responding to URL changes
+   *   urlService.listen();
+   *   urlService.sync();
+   * });
+   * ```
+   *
+   * @param enabled `true` or `false` to start or stop listening to URL changes
+   */
+  listen(enabled: any): any;
+  _stopListeningFn: any;
+  /**
+   * Disables monitoring of the URL.
+   *
+   * Call this method before ng-router has bootstrapped.
+   * It will stop ng-router from performing the initial url sync.
+   *
+   * This can be useful to perform some asynchronous initialization before the router starts.
+   * Once the initialization is complete, call [[listen]] to tell ng-router to start watching and synchronizing the URL.
+   *
+   * #### Example:
+   * ```js
+   * // Prevent ng-router from automatically intercepting URL changes when it starts;
+   * urlService.deferIntercept();
+   *
+   * fetch('/states.json').then(resp => resp.json()).then(data => {
+   *   data.forEach(state => $stateRegistry.register(state));
+   *   urlService.listen();
+   *   urlService.sync();
+   * });
+   * ```
+   *
+   * @param defer Indicates whether to defer location change interception.
+   *        Passing no parameter is equivalent to `true`.
+   */
+  deferIntercept(defer: any): void;
+  /**
+   * Matches a URL
+   *
+   * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
+   * Return the result as a [[MatchResult]].
+   * @returns {angular.MatchResult}
+   */
+  match(url: any): angular.MatchResult;
+  update(read: any): void;
+  location: any;
+  /**
+   * Internal API.
+   *
+   * Pushes a new location to the browser history.
+   *
+   * @internal
+   * @param urlMatcher
+   * @param params
+   * @param options
+   */
+  push(urlMatcher: any, params: any, options: any): void;
+  /**
+   * Builds and returns a URL with interpolated parameters
+   *
+   * #### Example:
+   * ```js
+   * matcher = $umf.compile("/about/:person");
+   * params = { person: "bob" };
+   * $bob = $urlService.href(matcher, params);
+   * // $bob == "/about/bob";
+   * ```
+   *
+   * @param urlMatcher The [[UrlMatcher]] object which is used as the template of the URL to generate.
+   * @param params An object of parameter values to fill the matcher's required parameters.
+   * @param options Options object. The options are:
+   *
+   * - **`absolute`** - {boolean=false},  If true will generate an absolute url, e.g. "http://www.example.com/fullurl".
+   *
+   * @returns Returns the fully compiled URL, or `null` if `params` fail validation against `urlMatcher`
+   */
+  href(urlMatcher: any, params: any, options: any): any;
+  /**
+   * Creates a [[UrlMatcher]] for the specified pattern.
+   *
+   * @param pattern  The URL pattern.
+   * @param config  The config object hash.
+   * @returns The UrlMatcher.
+   */
+  compile(pattern: any, config: any): UrlMatcher;
+  /**
+   * Returns true if the specified object is a [[UrlMatcher]], or false otherwise.
+   *
+   * @param object  The object to perform the type check against.
+   * @returns `true` if the object matches the `UrlMatcher` interface, by
+   *          implementing all the same methods.
+   */
+  isMatcher(object: any): boolean;
+}
+import { UrlRuleFactory } from "./url-rule";
+import { UrlRules } from "./url-rules";
+import { ParamFactory } from "../params/param-factory";
+import { UrlMatcher } from "./url-matcher";