@angular-wave/angular.ts 0.0.35 → 0.0.37

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

@@ -0,0 +1,390 @@
+/**
+ * Represents a transition between two states.
+ *
+ * When navigating to a state, we are transitioning **from** the current state **to** the new state.
+ *
+ * This object contains all contextual information about the to/from states, parameters, resolves.
+ * It has information about all states being entered and exited as a result of the transition.
+ */
+export class Transition {
+  /**
+   * Creates a new Transition object.
+   *
+   * If the target state is not valid, an error is thrown.
+   *
+   * @internal
+   *
+   * @param 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('../transition/transition-service').TransitionService} transitionService The [[TransitionService]] instance
+   * @internal
+   */
+  constructor(
+    fromPath: any,
+    targetState: any,
+    transitionService: import("../transition/transition-service").TransitionService,
+    globals: any,
+  );
+  globals: any;
+  transitionService: import("../transition/transition-service").TransitionService;
+  _deferred: any;
+  /**
+   * This promise is resolved or rejected based on the outcome of the Transition.
+   *
+   * When the transition is successful, the promise is resolved
+   * When the transition is unsuccessful, the promise is rejected with the [[Rejection]] or javascript error
+   */
+  promise: any;
+  /** @internal Holds the hook registration functions such as those passed to Transition.onStart() */
+  _registeredHooks: {};
+  _hookBuilder: HookBuilder;
+  /** Checks if this transition is currently active/running. */
+  isActive: () => boolean;
+  _targetState: any;
+  _options: any;
+  $id: number;
+  _treeChanges: {
+    from: any;
+    to: any;
+    retained: any;
+    retainedWithToParams: any;
+    exiting: any;
+    entering: any;
+  };
+  /**
+   * Creates the transition-level hook registration functions
+   * (which can then be used to register hooks)
+   */
+  createTransitionHookRegFns(): void;
+  getHooks(hookName: any): any;
+  applyViewConfigs(): void;
+  /**
+   * @internal
+   * @returns the internal from [State] object
+   */
+  $from(): any;
+  /**
+   * @internal
+   * @returns the internal to [State] object
+   */
+  $to(): any;
+  /**
+   * Returns the "from state"
+   *
+   * Returns the state that the transition is coming *from*.
+   *
+   * @returns The state declaration object for the Transition's ("from state").
+   */
+  from(): any;
+  /**
+   * Returns the "to state"
+   *
+   * Returns the state that the transition is going *to*.
+   *
+   * @returns The state declaration object for the Transition's target state ("to state").
+   */
+  to(): any;
+  /**
+   * Gets the Target State
+   *
+   * A transition's [[TargetState]] encapsulates the [[to]] state, the [[params]], and the [[options]] as a single object.
+   *
+   * @returns the [[TargetState]] of this Transition
+   */
+  targetState(): any;
+  /**
+   * Determines whether two transitions are equivalent.
+   * @deprecated
+   */
+  is(compare: any): any;
+  params(pathname?: string): any;
+  paramsChanged(): any;
+  /**
+   * Creates a [[UIInjector]] Dependency Injector
+   *
+   * Returns a Dependency Injector for the Transition's target state (to state).
+   * The injector provides resolve values which the target state has access to.
+   *
+   * The `UIInjector` can also provide values from the native root/global injector (ng1/ng2).
+   *
+   * #### Example:
+   * ```js
+   * .onEnter({ entering: 'myState' }, trans => {
+   *   var myResolveValue = trans.injector().get('myResolve');
+   *   // Inject a global service from the global/native injector (if it exists)
+   *   var MyService = trans.injector().get('MyService');
+   * })
+   * ```
+   *
+   * In some cases (such as `onBefore`), you may need access to some resolve data but it has not yet been fetched.
+   * You can use [[UIInjector.getAsync]] to get a promise for the data.
+   * #### Example:
+   * ```js
+   * .onBefore({}, trans => {
+   *   return trans.injector().getAsync('myResolve').then(myResolveValue =>
+   *     return myResolveValue !== 'ABORT';
+   *   });
+   * });
+   * ```
+   *
+   * If a `state` is provided, the injector that is returned will be limited to resolve values that the provided state has access to.
+   * This can be useful if both a parent state `foo` and a child state `foo.bar` have both defined a resolve such as `data`.
+   * #### Example:
+   * ```js
+   * .onEnter({ to: 'foo.bar' }, trans => {
+   *   // returns result of `foo` state's `myResolve` resolve
+   *   // even though `foo.bar` also has a `myResolve` resolve
+   *   var fooData = trans.injector('foo').get('myResolve');
+   * });
+   * ```
+   *
+   * If you need resolve data from the exiting states, pass `'from'` as `pathName`.
+   * The resolve data from the `from` path will be returned.
+   * #### Example:
+   * ```js
+   * .onExit({ exiting: 'foo.bar' }, trans => {
+   *   // Gets the resolve value of `myResolve` from the state being exited
+   *   var fooData = trans.injector(null, 'from').get('myResolve');
+   * });
+   * ```
+   *
+   *
+   * @param state Limits the resolves provided to only the resolves the provided state has access to.
+   * @param pathName Default: `'to'`: Chooses the path for which to create the injector. Use this to access resolves for `exiting` states.
+   *
+   * @returns a [[UIInjector]]
+   */
+  injector(
+    state: any,
+    pathName?: string,
+  ): {
+    context: any;
+    native: any;
+    get(token: any): any;
+    getAsync(token: any): any;
+    getNative(token: any): any;
+  };
+  /**
+   * Gets all available resolve tokens (keys)
+   *
+   * This method can be used in conjunction with [[injector]] to inspect the resolve values
+   * available to the Transition.
+   *
+   * This returns all the tokens defined on [[StateDeclaration.resolve]] blocks, for the states
+   * in the Transition's [[TreeChanges.to]] path.
+   *
+   * #### Example:
+   * This example logs all resolve values
+   * ```js
+   * let tokens = trans.getResolveTokens();
+   * tokens.forEach(token => console.log(token + " = " + trans.injector().get(token)));
+   * ```
+   *
+   * #### Example:
+   * This example creates promises for each resolve value.
+   * This triggers fetches of resolves (if any have not yet been fetched).
+   * When all promises have all settled, it logs the resolve values.
+   * ```js
+   * let tokens = trans.getResolveTokens();
+   * let promise = tokens.map(token => trans.injector().getAsync(token));
+   * Promise.all(promises).then(values => console.log("Resolved values: " + values));
+   * ```
+   *
+   * Note: Angular 1 users whould use `$q.all()`
+   *
+   * @param pathname resolve context's path name (e.g., `to` or `from`)
+   *
+   * @returns an array of resolve tokens (keys)
+   */
+  getResolveTokens(pathname?: string): any;
+  /**
+   * Dynamically adds a new [[Resolvable]] (i.e., [[StateDeclaration.resolve]]) to this transition.
+   *
+   * Allows a transition hook to dynamically add a Resolvable to this Transition.
+   *
+   * Use the [[Transition.injector]] to retrieve the resolved data in subsequent hooks ([[UIInjector.get]]).
+   *
+   * If a `state` argument is provided, the Resolvable is processed when that state is being entered.
+   * If no `state` is provided then the root state is used.
+   * If the given `state` has already been entered, the Resolvable is processed when any child state is entered.
+   * If no child states will be entered, the Resolvable is processed during the `onFinish` phase of the Transition.
+   *
+   * The `state` argument also scopes the resolved data.
+   * The resolved data is available from the injector for that `state` and any children states.
+   *
+   * #### Example:
+   * ```js
+   * transitionService.onBefore({}, transition => {
+   *   transition.addResolvable({
+   *     token: 'myResolve',
+   *     deps: ['MyService'],
+   *     resolveFn: myService => myService.getData()
+   *   });
+   * });
+   * ```
+   *
+   * @param resolvable a [[ResolvableLiteral]] object (or a [[Resolvable]])
+   * @param state the state in the "to path" which should receive the new resolve (otherwise, the root state)
+   */
+  addResolvable(resolvable: any, state?: string): void;
+  /**
+   * Gets the transition from which this transition was redirected.
+   *
+   * If the current transition is a redirect, this method returns the transition that was redirected.
+   *
+   * #### Example:
+   * ```js
+   * let transitionA = $state.go('A').transition
+   * transitionA.onStart({}, () => $state.target('B'));
+   * $transitions.onSuccess({ to: 'B' }, (trans) => {
+   *   trans.to().name === 'B'; // true
+   *   trans.redirectedFrom() === transitionA; // true
+   * });
+   * ```
+   *
+   * @returns The previous Transition, or null if this Transition is not the result of a redirection
+   */
+  redirectedFrom(): any;
+  /**
+   * Gets the original transition in a redirect chain
+   *
+   * A transition might belong to a long chain of multiple redirects.
+   * This method walks the [[redirectedFrom]] chain back to the original (first) transition in the chain.
+   *
+   * #### Example:
+   * ```js
+   * // states
+   * registry.register({ name: 'A', redirectTo: 'B' });
+   * registry.register({ name: 'B', redirectTo: 'C' });
+   * registry.register({ name: 'C', redirectTo: 'D' });
+   * registry.register({ name: 'D' });
+   *
+   * let transitionA = $state.go('A').transition
+   *
+   * $transitions.onSuccess({ to: 'D' }, (trans) => {
+   *   trans.to().name === 'D'; // true
+   *   trans.redirectedFrom().to().name === 'C'; // true
+   *   trans.originalTransition() === transitionA; // true
+   *   trans.originalTransition().to().name === 'A'; // true
+   * });
+   * ```
+   *
+   * @returns The original Transition that started a redirect chain
+   */
+  originalTransition(): any;
+  /**
+   * Get the transition options
+   *
+   * @returns the options for this Transition.
+   */
+  options(): any;
+  /**
+   * Gets the states being entered.
+   *
+   * @returns an array of states that will be entered during this transition.
+   */
+  entering(): any;
+  /**
+   * Gets the states being exited.
+   *
+   * @returns an array of states that will be exited during this transition.
+   */
+  exiting(): any;
+  /**
+   * Gets the states being retained.
+   *
+   * @returns an array of states that are already entered from a previous Transition, that will not be
+   *    exited during this Transition
+   */
+  retained(): any;
+  /**
+   * Get the [[ViewConfig]]s associated with this Transition
+   *
+   * Each state can define one or more views (template/controller), which are encapsulated as `ViewConfig` objects.
+   * This method fetches the `ViewConfigs` for a given path in the Transition (e.g., "to" or "entering").
+   *
+   * @param pathname the name of the path to fetch views for:
+   *   (`'to'`, `'from'`, `'entering'`, `'exiting'`, `'retained'`)
+   * @param state If provided, only returns the `ViewConfig`s for a single state in the path
+   *
+   * @returns a list of ViewConfig objects for the given path.
+   */
+  views(pathname: string, state: any): any;
+  treeChanges(pathname: any): any;
+  /**
+   * Creates a new transition that is a redirection of the current one.
+   *
+   * This transition can be returned from a [[TransitionService]] hook to
+   * redirect a transition to a new state and/or set of parameters.
+   *
+   * @internal
+   *
+   * @returns Returns a new [[Transition]] instance.
+   */
+  redirect(targetState: any): Transition;
+  /** @internal If a transition doesn't exit/enter any states, returns any [[Param]] whose value changed */
+  _changedParams(): any;
+  /**
+   * Returns true if the transition is dynamic.
+   *
+   * A transition is dynamic if no states are entered nor exited, but at least one dynamic parameter has changed.
+   *
+   * @returns true if the Transition is dynamic
+   */
+  dynamic(): any;
+  /**
+   * Returns true if the transition is ignored.
+   *
+   * A transition is ignored if no states are entered nor exited, and no parameter values have changed.
+   *
+   * @returns true if the Transition is ignored.
+   */
+  ignored(): boolean;
+  _ignoredReason(): "SameAsPending" | "SameAsCurrent";
+  /**
+   * Runs the transition
+   *
+   * This method is generally called from the [[StateService.transitionTo]]
+   *
+   * @internal
+   *
+   * @returns a promise for a successful transition.
+   */
+  run(): any;
+  success: boolean;
+  _error: any;
+  /**
+   * Checks if the Transition is valid
+   *
+   * @returns true if the Transition is valid
+   */
+  valid(): boolean;
+  /**
+   * Aborts this transition
+   *
+   * Imperative API to abort a Transition.
+   * This only applies to Transitions that are not yet complete.
+   */
+  abort(): void;
+  _aborted: boolean;
+  /**
+   * The Transition error reason.
+   *
+   * If the transition is invalid (and could not be run), returns the reason the transition is invalid.
+   * If the transition was valid and ran, but was not successful, returns the reason the transition failed.
+   *
+   * @returns a transition rejection explaining why the transition is invalid, or the reason the transition failed.
+   */
+  error(): any;
+  /**
+   * A string representation of the Transition
+   *
+   * @returns A string representation of the Transition
+   */
+  toString(): string;
+}
+export namespace Transition {
+  export { Transition as diToken };
+}
+import { HookBuilder } from "./hook-builder";

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

@@ -0,0 +1,100 @@
+/**
+ * An API to customize the URL behavior and retrieve URL configuration
+ *
+ * This API is used to customize the behavior of the URL.
+ * This includes optional trailing slashes ([[strictMode]]), case sensitivity ([[caseInsensitive]]),
+ * and custom parameter encoding (custom [[type]]).
+ *
+ * It also has information about the location (url) configuration such as [[port]] and [[baseHref]].
+ * This information can be used to build absolute URLs, such as
+ * `https://example.com:443/basepath/state/substate?param1=a#hashvalue`;
+ *
+ * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
+ */
+export class UrlConfigProvider {
+  /** @type {ParamTypes} */
+  paramTypes: ParamTypes;
+  /** @type {boolean} */
+  _isCaseInsensitive: boolean;
+  /** @type {boolean} */
+  _isStrictMode: boolean;
+  /** @type {boolean} */
+  _defaultSquashPolicy: boolean;
+  $get: (() => any)[];
+  /**
+   * Defines whether URL matching should be case sensitive (the default behavior), or not.
+   *
+   * #### Example:
+   * ```js
+   * // Allow case insensitive url matches
+   * urlService.config.caseInsensitive(true);
+   * ```
+   *
+   * @param value `false` to match URL in a case sensitive manner; otherwise `true`;
+   * @returns the current value of caseInsensitive
+   */
+  caseInsensitive(value: any): any;
+  /**
+   * Sets the default behavior when generating or matching URLs with default parameter values.
+   *
+   * #### Example:
+   * ```js
+   * // Remove default parameter values from the url
+   * urlService.config.defaultSquashPolicy(true);
+   * ```
+   *
+   * @param value A string that defines the default parameter URL squashing behavior.
+   *    - `nosquash`: When generating an href with a default parameter value, do not squash the parameter value from the URL
+   *    - `slash`: When generating an href with a default parameter value, squash (remove) the parameter value, and, if the
+   *      parameter is surrounded by slashes, squash (remove) one slash from the URL
+   *    - any other string, e.g. "~": When generating an href with a default parameter value, squash (remove)
+   *      the parameter value from the URL and replace it with this string.
+   * @returns the current value of defaultSquashPolicy
+   */
+  defaultSquashPolicy(value: any): any;
+  /**
+   * Defines whether URLs should match trailing slashes, or not (the default behavior).
+   *
+   * #### Example:
+   * ```js
+   * // Allow optional trailing slashes
+   * urlService.config.strictMode(false);
+   * ```
+   *
+   * @param value `false` to match trailing slashes in URLs, otherwise `true`.
+   * @returns the current value of strictMode
+   */
+  strictMode(value: any): any;
+  /**
+   * Creates and registers a custom [[ParamType]] object
+   *
+   * A custom parameter type can be used to generate URLs with typed parameters or custom encoding/decoding.
+   *
+   * #### Note: Register custom types *before using them* in a state definition.
+   *
+   * #### Example:
+   * ```js
+   * // Encode object parameter as JSON string
+   * urlService.config.type('myjson', {
+   *   encode: (obj) => JSON.stringify(obj),
+   *   decode: (str) => JSON.parse(str),
+   *   is: (val) => typeof(val) === 'object',
+   *   pattern: /[^/]+/,
+   *   equals: (a, b) => _.isEqual(a, b),
+   * });
+   * ```
+   *
+   * See [[ParamTypeDefinition]] for more examples
+   *
+   * @param name The type name.
+   * @param definition The type definition. See [[ParamTypeDefinition]] for information on the values accepted.
+   * @param definitionFn A function that is injected before the app runtime starts.
+   *        The result of this function should be a [[ParamTypeDefinition]].
+   *        The result is merged into the existing `definition`.
+   *        See [[ParamType]] for information on the values accepted.
+   *
+   * @returns if only the `name` parameter was specified: the currently registered [[ParamType]] object, or undefined
+   */
+  type(name: any, definition: any, definitionFn: any): any;
+}
+import { ParamTypes } from "../params/param-types";

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

@@ -0,0 +1,175 @@
+/**
+ * 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 class UrlMatcher {
+  static encodeDashes(str: any): string;
+  /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
+  static pathSegmentsAndParams(matcher: any): any;
+  /** @internal Given a matcher, return an array with the matcher's query params */
+  static queryParams(matcher: any): any;
+  /**
+   * 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: any, b: any): 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: any, paramTypes: any, paramFactory: any, config: any);
+  _cache: {
+    path: this[];
+  };
+  _children: any[];
+  _params: any[];
+  _segments: any[];
+  _compiled: any[];
+  config: any;
+  pattern: any;
+  /**
+   * 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: any): any;
+  isRoot(): boolean;
+  /** Returns the input pattern string */
+  toString(): any;
+  _getDecodedParamValue(value: any, param: any): any;
+  /**
+   * 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()`.
+   *
+   * @returns The captured parameter values.
+   */
+  exec(
+    path: any,
+    search: {},
+    hash: any,
+  ): {
+    "#": any;
+  };
+  /**
+   * @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?: {}): Array<Param>;
+  /**
+   * @internal
+   * Returns a single parameter from this UrlMatcher by id
+   *
+   * @param id
+   * @param opts
+   * @returns {T|Param|any|boolean|UrlMatcher|null}
+   */
+  parameter(id: any, opts?: {}): T | Param | any | boolean | UrlMatcher | null;
+  /**
+   * 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: any): any;
+  /**
+   * 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?: {}): string;
+}
+export namespace UrlMatcher {
+  let nameValidator: RegExp;
+}
+import { Param } from "../params/param";