@angular-wave/angular.ts 0.9.1 → 0.9.2

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

@@ -0,0 +1,138 @@
+export function $ViewDirectiveFill(
+  $compile: any,
+  $controller: any,
+  $transitions: any,
+): {
+  priority: number;
+  compile: (tElement: any) => (scope: any, $element: any) => void;
+};
+export namespace $ViewDirectiveFill {
+  let $inject: string[];
+}
+/**
+ * `ng-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 ng-view can be targeted in a View using the name ([[StateDeclaration.views]]).
+ *
+ * - `autoscroll`: an expression. When it evaluates to true, the `ng-view` will be scrolled into view when it is activated.
+ *   Uses [[$viewScroll]] to do the scrolling.
+ *
+ * - `onload`: Expression to evaluate whenever the view updates.
+ *
+ * #### Example:
+ * A view can be unnamed or named.
+ * ```html
+ * <!-- Unnamed -->
+ * <div ng-view></div>
+ *
+ * <!-- Named -->
+ * <div ng-view="viewName"></div>
+ *
+ * <!-- Named (different style) -->
+ * <ng-view name="viewName"></ng-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 ng-view></div>
+ * $stateProvider.state("home", {
+ *   template: "<h1>HELLO!</h1>"
+ * })
+ * ```
+ *
+ * The above is a convenient shortcut equivalent to specifying your view explicitly with the
+ * [[StateDeclaration.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 ng-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 ng-view></div>
+ * <div ng-view="chart"></div>
+ * <div ng-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 ng-view into view -->
+ * <ng-view autoscroll/>
+ *
+ * <!-- If autoscroll present with valid expression,
+ *      then scroll ng-view into view if expression evaluates to true -->
+ * <ng-view autoscroll='true'/>
+ * <ng-view autoscroll='false'/>
+ * <ng-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 [[ViewDeclaration.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(); }
+ *   }
+ * });
+ * ```
+ */
+/** @type {import("../../interface.js").AnnotatedDirectiveFactory} */
+export let ngView: import("../../interface.js").AnnotatedDirectiveFactory;

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

@@ -0,0 +1,81 @@
+/** Returns true if the string has glob-like characters in it
+ *  @param {string} text
+ *  @returns {boolean}
+ */
+export function hasGlobs(text: string): boolean;
+/**
+ * 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'`                 |
+ *
+ */
+export class Glob {
+  /** Returns a glob from the string, or null if the string isn't Glob-like
+   * @param {string} text
+   * @returns {?Glob}
+   */
+  static fromString(text: string): Glob | null;
+  /**
+   * @param {string} text
+   */
+  constructor(text: string);
+  /**
+   * @type {string}
+   */
+  text: string;
+  /**
+   * @type {string[]}
+   */
+  glob: string[];
+  /**
+   * @type {RegExp}
+   */
+  regexp: RegExp;
+  /**
+   * @param {string} name
+   * @return {boolean}
+   */
+  matches(name: string): boolean;
+}

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;