@angular-wave/angular.ts 0.0.60 → 0.0.62

package/types-back/router/core/url/urlMatcher.d.ts

@@ -1,185 +0,0 @@
-import { Param } from "../params/param";
-import { ParamTypes } from "../params/paramTypes";
-import { RawParams } from "../params/interface";
-import { UrlMatcherCompileConfig } from "./interface";
-import { ParamFactory } from "./urlMatcherFactory";
-/**
- * Matches URLs against patterns.
- *
- * Matches URLs against patterns and extracts named parameters from the path or the search
- * part of the URL.
- *
- * A URL pattern consists of a path pattern, optionally followed by '?' and a list of search (query)
- * parameters. Multiple search parameter names are separated by '&'. Search parameters
- * do not influence whether or not a URL is matched, but their values are passed through into
- * the matched parameters returned by [[UrlMatcher.exec]].
- *
- * - *Path parameters* are defined using curly brace placeholders (`/somepath/{param}`)
- * or colon placeholders (`/somePath/:param`).
- *
- * - *A parameter RegExp* may be defined for a param after a colon
- * (`/somePath/{param:[a-zA-Z0-9]+}`) in a curly brace placeholder.
- * The regexp must match for the url to be matched.
- * Should the regexp itself contain curly braces, they must be in matched pairs or escaped with a backslash.
- *
- * Note: a RegExp parameter will encode its value using either [[ParamTypes.path]] or [[ParamTypes.query]].
- *
- * - *Custom parameter types* may also be specified after a colon (`/somePath/{param:int}`) in curly brace parameters.
- *   See [[UrlMatcherFactory.type]] for more information.
- *
- * - *Catch-all parameters* are defined using an asterisk placeholder (`/somepath/*catchallparam`).
- *   A catch-all * parameter value will contain the remainder of the URL.
- *
- * ---
- *
- * Parameter names may contain only word characters (latin letters, digits, and underscore) and
- * must be unique within the pattern (across both path and search parameters).
- * A path parameter matches any number of characters other than '/'. For catch-all
- * placeholders the path parameter matches any number of characters.
- *
- * Examples:
- *
- * * `'/hello/'` - Matches only if the path is exactly '/hello/'. There is no special treatment for
- *   trailing slashes, and patterns have to match the entire path, not just a prefix.
- * * `'/user/:id'` - Matches '/user/bob' or '/user/1234!!!' or even '/user/' but not '/user' or
- *   '/user/bob/details'. The second path segment will be captured as the parameter 'id'.
- * * `'/user/{id}'` - Same as the previous example, but using curly brace syntax.
- * * `'/user/{id:[^/]*}'` - Same as the previous example.
- * * `'/user/{id:[0-9a-fA-F]{1,8}}'` - Similar to the previous example, but only matches if the id
- *   parameter consists of 1 to 8 hex digits.
- * * `'/files/{path:.*}'` - Matches any URL starting with '/files/' and captures the rest of the
- *   path into the parameter 'path'.
- * * `'/files/*path'` - ditto.
- * * `'/calendar/{start:date}'` - Matches "/calendar/2014-11-12" (because the pattern defined
- *   in the built-in  `date` ParamType matches `2014-11-12`) and provides a Date object in $stateParams.start
- *
- */
-export declare class UrlMatcher {
-  /** @internal */
-  static nameValidator: RegExp;
-  /** @internal */
-  private _cache;
-  /** @internal */
-  private _children;
-  /** @internal */
-  private _params;
-  /** @internal */
-  private _segments;
-  /** @internal */
-  private _compiled;
-  /** @internal */
-  private readonly config;
-  /** The pattern that was passed into the constructor */
-  pattern: string;
-  /** @internal */
-  static encodeDashes(str: string): string;
-  /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
-  static pathSegmentsAndParams(matcher: UrlMatcher): any;
-  /** @internal Given a matcher, return an array with the matcher's query params */
-  static queryParams(matcher: UrlMatcher): Param[];
-  /**
-   * Compare two UrlMatchers
-   *
-   * This comparison function converts a UrlMatcher into static and dynamic path segments.
-   * Each static path segment is a static string between a path separator (slash character).
-   * Each dynamic segment is a path parameter.
-   *
-   * The comparison function sorts static segments before dynamic ones.
-   */
-  static compare(a: UrlMatcher, b: UrlMatcher): number;
-  /**
-   * @param pattern The pattern to compile into a matcher.
-   * @param paramTypes The [[ParamTypes]] registry
-   * @param paramFactory A [[ParamFactory]] object
-   * @param config  A [[UrlMatcherCompileConfig]] configuration object
-   */
-  constructor(
-    pattern: string,
-    paramTypes: ParamTypes,
-    paramFactory: ParamFactory,
-    config?: UrlMatcherCompileConfig,
-  );
-  /**
-   * Creates a new concatenated UrlMatcher
-   *
-   * Builds a new UrlMatcher by appending another UrlMatcher to this one.
-   *
-   * @param url A `UrlMatcher` instance to append as a child of the current `UrlMatcher`.
-   */
-  append(url: UrlMatcher): UrlMatcher;
-  /** @internal */
-  isRoot(): boolean;
-  /** Returns the input pattern string */
-  toString(): string;
-  private _getDecodedParamValue;
-  /**
-   * Tests the specified url/path against this matcher.
-   *
-   * Tests if the given url matches this matcher's pattern, and returns an object containing the captured
-   * parameter values.  Returns null if the path does not match.
-   *
-   * The returned object contains the values
-   * of any search parameters that are mentioned in the pattern, but their value may be null if
-   * they are not present in `search`. This means that search parameters are always treated
-   * as optional.
-   *
-   * #### Example:
-   * ```js
-   * new UrlMatcher('/user/{id}?q&r').exec('/user/bob', {
-   *   x: '1', q: 'hello'
-   * });
-   * // 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 options
-   *
-   * @returns The captured parameter values.
-   */
-  exec(path: string, search?: any, hash?: string, options?: any): RawParams;
-  /**
-   * @internal
-   * Returns all the [[Param]] objects of all path and search parameters of this pattern in order of appearance.
-   *
-   * @returns {Array.<Param>}  An array of [[Param]] objects. Must be treated as read-only. If the
-   *    pattern has no parameters, an empty array is returned.
-   */
-  parameters(opts?: any): Param[];
-  /**
-   * @internal
-   * Returns a single parameter from this UrlMatcher by id
-   *
-   * @param id
-   * @param opts
-   * @returns {T|Param|any|boolean|UrlMatcher|null}
-   */
-  parameter(id: string, opts?: any): Param;
-  /**
-   * Validates the input parameter values against this UrlMatcher
-   *
-   * Checks an object hash of parameters to validate their correctness according to the parameter
-   * types of this `UrlMatcher`.
-   *
-   * @param params The object hash of parameters to validate.
-   * @returns Returns `true` if `params` validates, otherwise `false`.
-   */
-  validates(params: RawParams): boolean;
-  /**
-   * Given a set of parameter values, creates a URL from this UrlMatcher.
-   *
-   * Creates a URL that matches this pattern by substituting the specified values
-   * for the path and search parameters.
-   *
-   * #### Example:
-   * ```js
-   * new UrlMatcher('/user/{id}?q').format({ id:'bob', q:'yes' });
-   * // returns '/user/bob?q=yes'
-   * ```
-   *
-   * @param values  the values to substitute for the parameters in this pattern.
-   * @returns the formatted URL (path and optionally search part).
-   */
-  format(values?: RawParams): string;
-}

package/types-back/router/core/url/urlMatcherFactory.d.ts

@@ -1,56 +0,0 @@
-import { UrlMatcher } from "./urlMatcher";
-import { Param, ParamType, ParamTypeDefinition } from "../params";
-import { UrlMatcherCompileConfig } from "./interface";
-import { StateDeclaration } from "../state";
-import { Router } from "../router";
-export declare class ParamFactory {
-  private router;
-  fromConfig(id: string, type: ParamType, state: StateDeclaration): Param;
-  fromPath(id: string, type: ParamType, state: StateDeclaration): Param;
-  fromSearch(id: string, type: ParamType, state: StateDeclaration): Param;
-  constructor(router: Router);
-}
-/**
- * Factory for [[UrlMatcher]] instances.
- *
- * The factory is available to ng1 services as
- * `$urlMatcherFactory` or ng1 providers as `$urlServiceProvider`.
- */
-export declare class UrlMatcherFactory {
-  private router;
-  /** Creates a new [[Param]] for a given location (DefType) */
-  paramFactory: ParamFactory;
-  UrlMatcher: typeof UrlMatcher;
-  Param: typeof Param;
-  constructor(/** @internal */ router: Router);
-  /**
-   * Creates a [[UrlMatcher]] for the specified pattern.
-   *
-   * @param pattern  The URL pattern.
-   * @param config  The config object hash.
-   * @returns The UrlMatcher.
-   */
-  compile(pattern: string, config?: UrlMatcherCompileConfig): 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;
-  /** @internal */
-  $get(): this;
-  /** @deprecated use [[UrlConfig.caseInsensitive]] */
-  caseInsensitive: (value?: boolean) => boolean;
-  /** @deprecated use [[UrlConfig.defaultSquashPolicy]] */
-  defaultSquashPolicy: (value?: boolean | string) => string | boolean;
-  /** @deprecated use [[UrlConfig.strictMode]] */
-  strictMode: (value?: boolean) => boolean;
-  /** @deprecated use [[UrlConfig.type]] */
-  type: (
-    name: string,
-    definition?: ParamTypeDefinition,
-    definitionFn?: () => ParamTypeDefinition,
-  ) => any;
-}

package/types-back/router/core/url/urlRouter.d.ts

@@ -1,101 +0,0 @@
-import { UrlMatcher } from "./urlMatcher";
-import { RawParams } from "../params";
-import { Router } from "../router";
-import { UrlRuleFactory } from "./urlRule";
-import { MatchResult, UrlParts, UrlRule, UrlRuleHandlerFn } from "./interface";
-import { TargetState, TargetStateDef } from "../state";
-/**
- * Updates URL and responds to URL changes
- *
- * ### Deprecation warning:
- * This class is now considered to be an internal API
- * Use the [[UrlService]] instead.
- * For configuring URL rules, use the [[UrlRules]] which can be found as [[UrlService.rules]].
- */
-export declare class UrlRouter {
-  private router;
-  /** used to create [[UrlRule]] objects for common cases */
-  urlRuleFactory: UrlRuleFactory;
-  /** @internal */ private location;
-  /** @internal */
-  constructor(/** @internal */ router: Router);
-  /** Internal API. */
-  update(read?: boolean): void;
-  /**
-   * Internal API.
-   *
-   * Pushes a new location to the browser history.
-   *
-   * @internal
-   * @param urlMatcher
-   * @param params
-   * @param options
-   */
-  push(
-    urlMatcher: UrlMatcher,
-    params?: RawParams,
-    options?: {
-      replace?: string | boolean;
-    },
-  ): void;
-  /**
-   * Builds and returns a URL with interpolated parameters
-   *
-   * #### Example:
-   * ```js
-   * matcher = $umf.compile("/about/:person");
-   * params = { person: "bob" };
-   * $bob = $urlRouter.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: UrlMatcher,
-    params?: any,
-    options?: {
-      absolute: boolean;
-    },
-  ): string;
-  /** @deprecated use [[UrlService.sync]]*/
-  sync: (evt?: any) => void;
-  /** @deprecated use [[UrlService.listen]]*/
-  listen: (enabled?: boolean) => Function;
-  /** @deprecated use [[UrlService.deferIntercept]]*/
-  deferIntercept: (defer?: boolean) => void;
-  /** @deprecated use [[UrlService.interceptDeferred]]*/
-  interceptDeferred: boolean;
-  /** @deprecated use [[UrlService.match]]*/
-  match: (urlParts: UrlParts) => MatchResult;
-  /** @deprecated use [[UrlRules.initial]]*/
-  initial: (
-    handler: string | UrlRuleHandlerFn | TargetState | TargetStateDef,
-  ) => void;
-  /** @deprecated use [[UrlRules.otherwise]]*/
-  otherwise: (
-    handler: string | UrlRuleHandlerFn | TargetState | TargetStateDef,
-  ) => void;
-  /** @deprecated use [[UrlRules.removeRule]]*/
-  removeRule: (rule: UrlRule) => void;
-  /** @deprecated use [[UrlRules.rule]]*/
-  rule: (rule: UrlRule) => Function;
-  /** @deprecated use [[UrlRules.rules]]*/
-  rules: () => UrlRule[];
-  /** @deprecated use [[UrlRules.sort]]*/
-  sort: (compareFn?: (a: UrlRule, b: UrlRule) => number) => void;
-  /** @deprecated use [[UrlRules.when]]*/
-  when: (
-    matcher: RegExp | UrlMatcher | string,
-    handler: string | UrlRuleHandlerFn,
-    options?: {
-      priority: number;
-    },
-  ) => UrlRule;
-}

package/types-back/router/core/url/urlRule.d.ts

@@ -1,143 +0,0 @@
-import { StateDeclaration } from "../state";
-import { UrlMatcher } from "./urlMatcher";
-import { Router } from "../router";
-import { StateObject } from "../state/stateObject";
-import {
-  UrlRule,
-  UrlRuleMatchFn,
-  UrlRuleHandlerFn,
-  UrlRuleType,
-  MatcherUrlRule,
-  StateRule,
-  RegExpRule,
-} from "./interface";
-/**
- * Creates a [[UrlRule]]
- *
- * Creates a [[UrlRule]] from a:
- *
- * - `string`
- * - [[UrlMatcher]]
- * - `RegExp`
- * - [[StateObject]]
- */
-export declare class UrlRuleFactory {
-  router: Router;
-  static isUrlRule: (obj: any) => boolean;
-  constructor(router: Router);
-  compile(str: string): UrlMatcher;
-  create(
-    what:
-      | string
-      | UrlMatcher
-      | StateObject
-      | StateDeclaration
-      | RegExp
-      | UrlRuleMatchFn,
-    handler?: string | UrlRuleHandlerFn,
-  ): UrlRule;
-  /**
-   * 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 ([[Router]])
-   *
-   * #### 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: UrlMatcher,
-    handler: string | UrlMatcher | UrlRuleHandlerFn,
-  ): MatcherUrlRule;
-  /**
-   * 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: StateObject | StateDeclaration,
-    router: Router,
-  ): StateRule;
-  /**
-   * 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 ([[Router]])
-   *
-   * #### 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: RegExp, handler: string | UrlRuleHandlerFn): RegExpRule;
-}
-/**
- * A base rule which calls `match`
- *
- * The value from the `match` function is passed through to the `handler`.
- * @internal
- */
-export declare class BaseUrlRule implements UrlRule {
-  match: UrlRuleMatchFn;
-  $id: number;
-  priority: number;
-  _group: number;
-  type: UrlRuleType;
-  handler: UrlRuleHandlerFn;
-  matchPriority: (match: any) => number;
-  constructor(match: UrlRuleMatchFn, handler?: UrlRuleHandlerFn);
-}