@angular-wave/angular.ts 0.0.35 → 0.0.37

package/types/router/common/glob.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Matches state names using glob-like pattern strings.
+ *
+ * Globs can be used in specific APIs including:
+ *
+ * - [[StateService.is]]
+ * - [[StateService.includes]]
+ * - The first argument to Hook Registration functions like [[TransitionService.onStart]]
+ *    - [[HookMatchCriteria]] and [[HookMatchCriterion]]
+ *
+ * A `Glob` string is a pattern which matches state names.
+ * Nested state names are split into segments (separated by a dot) when processing.
+ * The state named `foo.bar.baz` is split into three segments ['foo', 'bar', 'baz']
+ *
+ * Globs work according to the following rules:
+ *
+ * ### Exact match:
+ *
+ * The glob `'A.B'` matches the state named exactly `'A.B'`.
+ *
+ * | Glob        |Matches states named|Does not match state named|
+ * |:------------|:--------------------|:---------------------|
+ * | `'A'`       | `'A'`               | `'B'` , `'A.C'`      |
+ * | `'A.B'`     | `'A.B'`             | `'A'` , `'A.B.C'`    |
+ * | `'foo'`     | `'foo'`             | `'FOO'` , `'foo.bar'`|
+ *
+ * ### Single star (`*`)
+ *
+ * A single star (`*`) is a wildcard that matches exactly one segment.
+ *
+ * | Glob        |Matches states named  |Does not match state named |
+ * |:------------|:---------------------|:--------------------------|
+ * | `'*'`       | `'A'` , `'Z'`        | `'A.B'` , `'Z.Y.X'`       |
+ * | `'A.*'`     | `'A.B'` , `'A.C'`    | `'A'` , `'A.B.C'`         |
+ * | `'A.*.*'`   | `'A.B.C'` , `'A.X.Y'`| `'A'`, `'A.B'` , `'Z.Y.X'`|
+ *
+ * ### Double star (`**`)
+ *
+ * A double star (`'**'`) is a wildcard that matches *zero or more segments*
+ *
+ * | Glob        |Matches states named                           |Does not match state named         |
+ * |:------------|:----------------------------------------------|:----------------------------------|
+ * | `'**'`      | `'A'` , `'A.B'`, `'Z.Y.X'`                    | (matches all states)              |
+ * | `'A.**'`    | `'A'` , `'A.B'` , `'A.C.X'`                   | `'Z.Y.X'`                         |
+ * | `'**.X'`    | `'X'` , `'A.X'` , `'Z.Y.X'`                   | `'A'` , `'A.login.Z'`             |
+ * | `'A.**.X'`  | `'A.X'` , `'A.B.X'` , `'A.B.C.X'`             | `'A'` , `'A.B.C'`                 |
+ *
+ * @packageDocumentation
+ */
+export class Glob {
+  /** Returns true if the string has glob-like characters in it */
+  static is(text: any): boolean;
+  /** Returns a glob from the string, or null if the string isn't Glob-like */
+  static fromString(text: any): Glob;
+  constructor(text: any);
+  text: any;
+  glob: any;
+  regexp: RegExp;
+  matches(name: any): boolean;
+}

package/types/router/common/queue.d.ts

@@ -0,0 +1,15 @@
+export class Queue {
+  constructor(_items?: any[], _limit?: any);
+  _items: any[];
+  _limit: any;
+  _evictListeners: any[];
+  onEvict: any;
+  enqueue(item: any): any;
+  evict(): any;
+  dequeue(): any;
+  clear(): any[];
+  size(): number;
+  remove(item: any): any;
+  peekTail(): any;
+  peekHead(): any;
+}

package/types/router/common/trace.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Prints ng-router Transition trace information to the console.
+ */
+export class Trace {
+  _enabled: {};
+  approximateDigests: number;
+  _set(enabled: any, categories: any): void;
+  enable(...categories: any[]): void;
+  disable(...categories: any[]): void;
+  /**
+   * Retrieves the enabled stateus of a [[Category]]
+   *
+   * ```js
+   * trace.enabled("VIEWCONFIG"); // true or false
+   * ```
+   *
+   * @returns boolean true if the category is enabled
+   */
+  enabled(category: any): boolean;
+  /** @internal called by ui-router code */
+  traceTransitionStart(trans: any): void;
+  /** @internal called by ui-router code */
+  traceTransitionIgnored(trans: any): void;
+  /** @internal called by ui-router code */
+  traceHookInvocation(step: any, trans: any, options: any): void;
+  /** @internal called by ui-router code */
+  traceHookResult(hookResult: any, trans: any): void;
+  /** @internal called by ui-router code */
+  traceResolvePath(path: any, when: any, trans: any): void;
+  /** @internal called by ui-router code */
+  traceResolvableResolved(resolvable: any, trans: any): void;
+  /** @internal called by ui-router code */
+  traceError(reason: any, trans: any): void;
+  /** @internal called by ui-router code */
+  traceSuccess(finalState: any, trans: any): void;
+  /** @internal called by ui-router code */
+  traceUIViewEvent(event: any, viewData: any, extra?: string): void;
+  /** @internal called by ui-router code */
+  traceUIViewConfigUpdated(viewData: any, context: any): void;
+  /** @internal called by ui-router code */
+  traceUIViewFill(viewData: any, html: any): void;
+  /** @internal called by ui-router code */
+  traceViewSync(pairs: any): void;
+  /** @internal called by ui-router code */
+  traceViewServiceEvent(event: any, viewConfig: any): void;
+  /** @internal called by ui-router code */
+  traceViewServiceUIViewEvent(event: any, viewData: any): void;
+}
+/**
+ * The [[Trace]] singleton
+ *
+ * #### Example:
+ * ```js
+ * import {trace} from "@uirouter/core/index";
+ * trace.enable(1, 5);
+ * ```
+ */
+export const trace: Trace;
+/**
+ * Trace categories Enum
+ *
+ * Enable or disable a category using [[Trace.enable]] or [[Trace.disable]]
+ *
+ * `trace.enable(Category.TRANSITION)`
+ *
+ * These can also be provided using a matching string, or position ordinal
+ *
+ * `trace.enable("TRANSITION")`
+ *
+ * `trace.enable(1)`
+ */
+export var Category: any;

package/types/router/directives/view-directive.d.ts

@@ -0,0 +1,160 @@
+export function $ViewDirectiveFill(
+  $compile: any,
+  $controller: any,
+  $transitions: any,
+  $view: any,
+  $q: any,
+): {
+  restrict: string;
+  priority: number;
+  compile: (tElement: any) => (scope: any, $element: any) => void;
+};
+export namespace $ViewDirectiveFill {
+  let $inject: string[];
+}
+/**
+ * `ui-view`: A viewport directive which is filled in by a view from the active state.
+ *
+ * ### Attributes
+ *
+ * - `name`: (Optional) A view name.
+ *   The name should be unique amongst the other views in the same state.
+ *   You can have views of the same name that live in different states.
+ *   The ui-view can be targeted in a View using the name ([[Ng1StateDeclaration.views]]).
+ *
+ * - `autoscroll`: an expression. When it evaluates to true, the `ui-view` will be scrolled into view when it is activated.
+ *   Uses [[$ngViewScroll]] to do the scrolling.
+ *
+ * - `onload`: Expression to evaluate whenever the view updates.
+ *
+ * #### Example:
+ * A view can be unnamed or named.
+ * ```html
+ * <!-- Unnamed -->
+ * <div ui-view></div>
+ *
+ * <!-- Named -->
+ * <div ui-view="viewName"></div>
+ *
+ * <!-- Named (different style) -->
+ * <ui-view name="viewName"></ui-view>
+ * ```
+ *
+ * You can only have one unnamed view within any template (or root html). If you are only using a
+ * single view and it is unnamed then you can populate it like so:
+ *
+ * ```html
+ * <div ui-view></div>
+ * $stateProvider.state("home", {
+ *   template: "<h1>HELLO!</h1>"
+ * })
+ * ```
+ *
+ * The above is a convenient shortcut equivalent to specifying your view explicitly with the
+ * [[Ng1StateDeclaration.views]] config property, by name, in this case an empty name:
+ *
+ * ```js
+ * $stateProvider.state("home", {
+ *   views: {
+ *     "": {
+ *       template: "<h1>HELLO!</h1>"
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * But typically you'll only use the views property if you name your view or have more than one view
+ * in the same template. There's not really a compelling reason to name a view if its the only one,
+ * but you could if you wanted, like so:
+ *
+ * ```html
+ * <div ui-view="main"></div>
+ * ```
+ *
+ * ```js
+ * $stateProvider.state("home", {
+ *   views: {
+ *     "main": {
+ *       template: "<h1>HELLO!</h1>"
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * Really though, you'll use views to set up multiple views:
+ *
+ * ```html
+ * <div ui-view></div>
+ * <div ui-view="chart"></div>
+ * <div ui-view="data"></div>
+ * ```
+ *
+ * ```js
+ * $stateProvider.state("home", {
+ *   views: {
+ *     "": {
+ *       template: "<h1>HELLO!</h1>"
+ *     },
+ *     "chart": {
+ *       template: "<chart_thing/>"
+ *     },
+ *     "data": {
+ *       template: "<data_thing/>"
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * #### Examples for `autoscroll`:
+ * ```html
+ * <!-- If autoscroll present with no expression,
+ *      then scroll ui-view into view -->
+ * <ui-view autoscroll/>
+ *
+ * <!-- If autoscroll present with valid expression,
+ *      then scroll ui-view into view if expression evaluates to true -->
+ * <ui-view autoscroll='true'/>
+ * <ui-view autoscroll='false'/>
+ * <ui-view autoscroll='scopeVariable'/>
+ * ```
+ *
+ * Resolve data:
+ *
+ * The resolved data from the state's `resolve` block is placed on the scope as `$resolve` (this
+ * can be customized using [[Ng1ViewDeclaration.resolveAs]]).  This can be then accessed from the template.
+ *
+ * Note that when `controllerAs` is being used, `$resolve` is set on the controller instance *after* the
+ * controller is instantiated.  The `$onInit()` hook can be used to perform initialization code which
+ * depends on `$resolve` data.
+ *
+ * #### Example:
+ * ```js
+ * $stateProvider.state('home', {
+ *   template: '<my-component user="$resolve.user"></my-component>',
+ *   resolve: {
+ *     user: function(UserService) { return UserService.fetchUser(); }
+ *   }
+ * });
+ * ```
+ */
+export let ngView: (
+  | string
+  | ((
+      $view: any,
+      $animate: any,
+      $ngViewScroll: any,
+      $interpolate: any,
+      $q: any,
+    ) => {
+      count: number;
+      restrict: string;
+      terminal: boolean;
+      priority: number;
+      transclude: string;
+      compile: (
+        tElement: any,
+        tAttrs: any,
+        $transclude: any,
+      ) => (scope: any, $element: any, attrs: any) => void;
+    })
+)[];

package/types/router/globals.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Global router state
+ *
+ * This is where we hold the global mutable state such as current state, current
+ * params, current transition, etc.
+ */
+export class UIRouterGlobals {
+  /**
+   * Current parameter values
+   *
+   * The parameter values from the latest successful transition
+   * @type {StateParams}
+   */
+  params: StateParams;
+  /**
+   * @type {Number}
+   */
+  lastStartedTransitionId: number;
+  /**
+   * @type {Queue}
+   */
+  transitionHistory: Queue;
+  /**
+   * @type {Queue}
+   */
+  successfulTransitions: Queue;
+  $get: (() => this)[];
+}
+import { StateParams } from "./params/state-params";
+import { Queue } from "./common/queue";

package/types/router/hooks/core-resolvables.d.ts

@@ -0,0 +1,2 @@
+export function registerAddCoreResolvables(transitionService: any): void;
+export function treeChangesCleanup(trans: any): void;

package/types/router/hooks/ignored-transition.d.ts

@@ -0,0 +1 @@
+export function registerIgnoredTransitionHook(transitionService: any): any;

package/types/router/hooks/invalid-transition.d.ts

@@ -0,0 +1 @@
+export function registerInvalidTransitionHook(transitionService: any): any;

package/types/router/hooks/lazy-load.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A [[TransitionHookFn]] that performs lazy loading
+ *
+ * When entering a state "abc" which has a `lazyLoad` function defined:
+ * - Invoke the `lazyLoad` function (unless it is already in process)
+ *   - Flag the hook function as "in process"
+ *   - The function should return a promise (that resolves when lazy loading is complete)
+ * - Wait for the promise to settle
+ *   - If the promise resolves to a [[LazyLoadResult]], then register those states
+ *   - Flag the hook function as "not in process"
+ * - If the hook was successful
+ *   - Remove the `lazyLoad` function from the state declaration
+ * - If all the hooks were successful
+ *   - Retry the transition (by returning a TargetState)
+ *
+ * ```
+ * .state('abc', {
+ *   component: 'fooComponent',
+ *   lazyLoad: () => import('./fooComponent')
+ *   });
+ * ```
+ *
+ * See [[StateDeclaration.lazyLoad]]
+ */
+export function registerLazyLoadHook(
+  transitionService: any,
+  stateService: any,
+  urlService: any,
+  stateRegistry: any,
+): any;
+/**
+ * Invokes a state's lazy load function
+ *
+ * @param transition a Transition context
+ * @param state the state to lazy load
+ * @returns A promise for the lazy load result
+ */
+export function lazyLoadState(
+  transition: any,
+  state: any,
+  stateRegistry: any,
+): any;

package/types/router/hooks/on-enter-exit-retain.d.ts

@@ -0,0 +1,3 @@
+export function registerOnExitHook(transitionService: any): any;
+export function registerOnRetainHook(transitionService: any): any;
+export function registerOnEnterHook(transitionService: any): any;

package/types/router/hooks/redirect-to.d.ts

@@ -0,0 +1,4 @@
+export function registerRedirectToHook(
+  transitionService: any,
+  stateService: any,
+): void;

package/types/router/hooks/resolve.d.ts

@@ -0,0 +1,4 @@
+export const RESOLVE_HOOK_PRIORITY: 1000;
+export function registerEagerResolvePath(transitionService: any): any;
+export function registerLazyResolveState(transitionService: any): any;
+export function registerResolveRemaining(transitionService: any): any;

package/types/router/hooks/update-globals.d.ts

@@ -0,0 +1 @@
+export function registerUpdateGlobalState(transitionService: any): any;

package/types/router/hooks/url.d.ts

@@ -0,0 +1,5 @@
+export function registerUpdateUrl(
+  transitionService: any,
+  stateService: any,
+  urlService: any,
+): void;

package/types/router/hooks/views.d.ts

@@ -0,0 +1,5 @@
+export function registerLoadEnteringViews(transitionService: any): any;
+export function registerActivateViews(
+  transitionService: any,
+  viewService: any,
+): void;

package/types/router/index.d.ts

@@ -1,17 +1 @@
-/**
- * Main entry point for angular 1.x build
- */ /** */
-export * from "./interface";
-export * from "./services";
-export * from "./statebuilders/views";
-export * from "./stateProvider";
-import "./injectables";
-import "./directives/stateDirectives";
-import "./stateFilters";
-import "./directives/viewDirective";
-import "./viewScroll";
-declare const _default: "router";
-export default _default;
-import * as core from "./core/index";
-export { core };
-export * from "./core/index";
+export function initRouter(): void;

package/types/router/injectables.d.ts

@@ -0,0 +1 @@
+export {};

package/types/router/params/param-factory.d.ts

@@ -0,0 +1,8 @@
+export class ParamFactory {
+  constructor(urlServiceConfig: any);
+  urlServiceConfig: any;
+  fromConfig(id: any, type: any, state: any): Param;
+  fromPath(id: any, type: any, state: any): Param;
+  fromSearch(id: any, type: any, state: any): Param;
+}
+import { Param } from "../params/param";

package/types/router/params/param-type.d.ts

@@ -0,0 +1,65 @@
+/**
+ * An internal class which implements [[ParamTypeDefinition]].
+ *
+ * A [[ParamTypeDefinition]] is a plain javascript object used to register custom parameter types.
+ * When a param type definition is registered, an instance of this class is created internally.
+ *
+ * This class has naive implementations for all the [[ParamTypeDefinition]] methods.
+ *
+ * Used by [[UrlMatcher]] when matching or formatting URLs, or comparing and validating parameter values.
+ *
+ * #### Example:
+ * ```js
+ * var paramTypeDef = {
+ *   decode: function(val) { return parseInt(val, 10); },
+ *   encode: function(val) { return val && val.toString(); },
+ *   equals: function(a, b) { return this.is(a) && a === b; },
+ *   is: function(val) { return angular.isNumber(val) && isFinite(val) && val % 1 === 0; },
+ *   pattern: /\d+/
+ * }
+ *
+ * var paramType = new ParamType(paramTypeDef);
+ * ```
+ */
+export class ParamType {
+  /**
+   * @param def  A configuration object which contains the custom type definition.  The object's
+   *        properties will override the default methods and/or pattern in `ParamType`'s public interface.
+   * @returns a new ParamType object
+   */
+  constructor(def: any);
+  /** @inheritdoc */
+  pattern: RegExp;
+  /** @inheritdoc */
+  inherit: boolean;
+  /** @inheritdoc */
+  is(val: any, key: any): boolean;
+  /** @inheritdoc */
+  encode(val: any, key: any): any;
+  /** @inheritdoc */
+  decode(val: any, key: any): any;
+  /** @inheritdoc */
+  equals(a: any, b: any): boolean;
+  $subPattern(): string;
+  toString(): string;
+  /** Given an encoded string, or a decoded object, returns a decoded object */
+  $normalize(val: any): any;
+  /**
+   * Wraps an existing custom ParamType as an array of ParamType, depending on 'mode'.
+   * e.g.:
+   * - urlmatcher pattern "/path?{queryParam[]:int}"
+   * - url: "/path?queryParam=1&queryParam=2
+   * - $stateParams.queryParam will be [1, 2]
+   * if `mode` is "auto", then
+   * - url: "/path?queryParam=1 will create $stateParams.queryParam: 1
+   * - url: "/path?queryParam=1&queryParam=2 will create $stateParams.queryParam: [1, 2]
+   */
+  $asArray(mode: any, isSearch: any): ArrayType;
+}
+/** Wraps up a `ParamType` object to handle array values. */
+declare function ArrayType(type: any, mode: any): void;
+declare class ArrayType {
+  /** Wraps up a `ParamType` object to handle array values. */
+  constructor(type: any, mode: any);
+}
+export {};

package/types/router/params/param-types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A registry for parameter types.
+ *
+ * This registry manages the built-in (and custom) parameter types.
+ *
+ * The built-in parameter types are:
+ *
+ * - [[string]]
+ * - [[path]]
+ * - [[query]]
+ * - [[hash]]
+ * - [[int]]
+ * - [[bool]]
+ * - [[date]]
+ * - [[json]]
+ * - [[any]]
+ *
+ * To register custom parameter types, use [[UrlConfig.type]], i.e.,
+ *
+ * ```js
+ * router.urlService.config.type(customType)
+ * ```
+ */
+export class ParamTypes {
+  enqueue: boolean;
+  typeQueue: any[];
+  defaultTypes: {};
+  types: any;
+  /**
+   * Registers a parameter type
+   *
+   * End users should call [[UrlMatcherFactory.type]], which delegates to this method.
+   */
+  type(name: any, definition: any, definitionFn: any): any;
+  _flushTypeQueue(): void;
+}

package/types/router/params/param.d.ts

@@ -0,0 +1,41 @@
+export class Param {
+  static values(params: any, values?: {}): {};
+  /**
+   * Finds [[Param]] objects which have different param values
+   *
+   * Filters a list of [[Param]] objects to only those whose parameter values differ in two param value objects
+   *
+   * @param params: The list of Param objects to filter
+   * @param values1: The first set of parameter values
+   * @param values2: the second set of parameter values
+   *
+   * @returns any Param objects whose values were different between values1 and values2
+   */
+  static changed(params: any, values1?: {}, values2?: {}): any;
+  /**
+   * Checks if two param value objects are equal (for a set of [[Param]] objects)
+   *
+   * @param params The list of [[Param]] objects to check
+   * @param values1 The first set of param values
+   * @param values2 The second set of param values
+   *
+   * @returns true if the param values in values1 and values2 are equal
+   */
+  static equals(params: any, values1?: {}, values2?: {}): boolean;
+  /** Returns true if a the parameter values are valid, according to the Param definitions */
+  static validates(params: any, values?: {}): any;
+  constructor(id: any, type: any, location: any, urlConfig: any, state: any);
+  isDefaultValue(value: any): any;
+  /**
+   * [Internal] Gets the decoded representation of a value if the value is defined, otherwise, returns the
+   * default value, which may be the result of an injectable function.
+   */
+  value(value: any): any;
+  _defaultValueCache: {
+    defaultValue: any;
+  };
+  isSearch(): boolean;
+  validates(value: any): boolean;
+  toString(): string;
+}
+export var DefType: any;

package/types/router/params/state-params.d.ts

@@ -0,0 +1,12 @@
+export class StateParams {
+  constructor(params?: {});
+  /**
+   * Merges a set of parameters with all parameters inherited between the common parents of the
+   * current state and a given destination state.
+   *
+   * @param {Object} newParams The set of parameters which will be composited with inherited params.
+   * @param {Object} $current Internal definition of object representing the current state.
+   * @param {Object} $to Internal definition of object representing state to transition to.
+   */
+  $inherit(newParams: any, $current: any, $to: any): any;
+}

package/types/router/path/path-node.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A node in a [[TreeChanges]] path
+ *
+ * For a [[TreeChanges]] path, this class holds the stateful information for a single node in the path.
+ * Each PathNode corresponds to a state being entered, exited, or retained.
+ * The stateful information includes parameter values and resolve data.
+ */
+export class PathNode {
+  constructor(stateOrNode: any);
+  state: any;
+  paramSchema: any;
+  paramValues: any;
+  resolvables: any;
+  views: any;
+  clone(): PathNode;
+  /** Sets [[paramValues]] for the node, from the values of an object hash */
+  applyRawParams(params: any): this;
+  /** Gets a specific [[Param]] metadata that belongs to the node */
+  parameter(name: any): undefined;
+  /**
+   * @returns true if the state and parameter values for another PathNode are
+   * equal to the state and param values for this PathNode
+   */
+  equals(node: any, paramsFn: any): boolean;
+  /**
+   * Finds Params with different parameter values on another PathNode.
+   *
+   * Given another node (of the same state), finds the parameter values which differ.
+   * Returns the [[Param]] (schema objects) whose parameter values differ.
+   *
+   * Given another node for a different state, returns `false`
+   *
+   * @param node The node to compare to
+   * @param paramsFn A function that returns which parameters should be compared.
+   * @returns The [[Param]]s which differ, or null if the two nodes are for different states
+   */
+  diff(node: any, paramsFn: any): any;
+}
+export namespace PathNode {
+  /**
+   * Returns a clone of the PathNode
+   * @deprecated use instance method `node.clone()`
+   */
+  function clone(node: any): any;
+}