@angular-wave/angular.ts 0.9.1 → 0.9.3

package/@types/router/state/state-service.d.ts

@@ -0,0 +1,425 @@
+/**
+ * Provides services related to ng-router states.
+ *
+ * This API is located at `router.stateService` ([[UIRouter.stateService]])
+ */
+export class StateProvider {
+  static $inject: string[];
+  /**
+   *
+   * @param {import('../router.js').Router} globals
+   * @param {*} transitionService
+   * @param {import('../../core/di/internal-injector.js').InjectorService} $injector
+   */
+  constructor(
+    globals: import("../router.js").Router,
+    transitionService: any,
+    $injector: import("../../core/di/internal-injector.js").InjectorService,
+  );
+  /**
+   * The latest successful state parameters
+   *
+   * @deprecated This is a passthrough through to [[Router.params]]
+   */
+  get params(): import("../params/state-params.js").StateParams;
+  /**
+   * The current [[StateDeclaration]]
+   *
+   * @deprecated This is a passthrough through to [[Router.current]]
+   */
+  get current(): import("./interface.js").StateDeclaration;
+  /**
+   * The current [[StateObject]] (an internal API)
+   *
+   * @deprecated This is a passthrough through to [[Router.$current]]
+   */
+  get $current(): import("./state-object.js").StateObject;
+  stateRegistry: any;
+  urlService: any;
+  globals: import("../router.js").Router;
+  transitionService: any;
+  $injector: import("../../core/di/internal-injector.js").InjectorService;
+  invalidCallbacks: any[];
+  _defaultErrorHandler: ($error$: any) => never;
+  $get: () => this;
+  /**
+   * Decorates states when they are registered
+   *
+   * Allows you to extend (carefully) or override (at your own peril) the
+   * `stateBuilder` object used internally by [[StateRegistry]].
+   * This can be used to add custom functionality to ng-router,
+   * for example inferring templateUrl based on the state name.
+   *
+   * When passing only a name, it returns the current (original or decorated) builder
+   * function that matches `name`.
+   *
+   * The builder functions that can be decorated are listed below. Though not all
+   * necessarily have a good use case for decoration, that is up to you to decide.
+   *
+   * In addition, users can attach custom decorators, which will generate new
+   * properties within the state's internal definition. There is currently no clear
+   * use-case for this beyond accessing internal states (i.e. $state.$current),
+   * however, expect this to become increasingly relevant as we introduce additional
+   * meta-programming features.
+   *
+   * **Warning**: Decorators should not be interdependent because the order of
+   * execution of the builder functions in non-deterministic. Builder functions
+   * should only be dependent on the state definition object and super function.
+   *
+   *
+   * Existing builder functions and current return values:
+   *
+   * - **parent** `{object}` - returns the parent state object.
+   * - **data** `{object}` - returns state data, including any inherited data that is not
+   *   overridden by own values (if any).
+   * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}
+   *   or `null`.
+   * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is
+   *   navigable).
+   * - **params** `{object}` - returns an array of state params that are ensured to
+   *   be a super-set of parent's params.
+   * - **views** `{object}` - returns a views object where each key is an absolute view
+   *   name (i.e. "viewName@stateName") and each value is the urlConfig object
+   *   (template, controller) for the view. Even when you don't use the views object
+   *   explicitly on a state urlConfig, one is still created for you internally.
+   *   So by decorating this builder function you have access to decorating template
+   *   and controller properties.
+   * - **ownParams** `{object}` - returns an array of params that belong to the state,
+   *   not including any params defined by ancestor states.
+   * - **path** `{string}` - returns the full path from the root down to this state.
+   *   Needed for state activation.
+   * - **includes** `{object}` - returns an object that includes every state that
+   *   would pass a `$state.includes()` test.
+   *
+   * #### Example:
+   * Override the internal 'views' builder with a function that takes the state
+   * definition, and a reference to the internal function being overridden:
+   * ```js
+   * $stateProvider.decorator('views', function (state, parent) {
+   *   let result = {},
+   *       views = parent(state);
+   *
+   *   angular.forEach(views, function (urlConfig, name) {
+   *     let autoName = (state.name + '.' + name).replace('.', '/');
+   *     urlConfig.templateUrl = urlConfig.templateUrl || '/partials/' + autoName + '.html';
+   *     result[name] = urlConfig;
+   *   });
+   *   return result;
+   * });
+   *
+   * $stateProvider.state('home', {
+   *   views: {
+   *     'contact.list': { controller: 'ListController' },
+   *     'contact.item': { controller: 'ItemController' }
+   *   }
+   * });
+   * ```
+   *
+   *
+   * ```js
+   * // Auto-populates list and item views with /partials/home/contact/list.html,
+   * // and /partials/home/contact/item.html, respectively.
+   * $state.go('home');
+   * ```
+   *
+   * @param {string} name The name of the builder function to decorate.
+   * @param {object} func A function that is responsible for decorating the original
+   * builder function. The function receives two parameters:
+   *
+   *   - `{object}` - state - The state urlConfig object.
+   *   - `{object}` - super - The original builder function.
+   *
+   * @return {object} $stateProvider - $stateProvider instance
+   */
+  decorator(name: string, func: object): object;
+  /**
+   *
+   * @param {import("./interface.js").StateDeclaration} definition
+   */
+  state(definition: import("./interface.js").StateDeclaration): this;
+  /**
+   * Handler for when [[transitionTo]] is called with an invalid state.
+   *
+   * Invokes the [[onInvalid]] callbacks, in natural order.
+   * Each callback's return value is checked in sequence until one of them returns an instance of TargetState.
+   * The results of the callbacks are wrapped in Promise.resolve(), so the callbacks may return promises.
+   *
+   * If a callback returns an TargetState, then it is used as arguments to $state.transitionTo() and the result returned.
+   *
+   * @internal
+   */
+  _handleInvalidTargetState(fromPath: any, toState: any): any;
+  /**
+   * Registers an Invalid State handler
+   *
+   * Registers a [[OnInvalidCallback]] function to be invoked when [[StateService.transitionTo]]
+   * has been called with an invalid state reference parameter
+   *
+   * Example:
+   * ```js
+   * stateService.onInvalid(function(to, from, injector) {
+   *   if (to.name() === 'foo') {
+   *     let lazyLoader = injector.get('LazyLoadService');
+   *     return lazyLoader.load('foo')
+   *         .then(() => stateService.target('foo'));
+   *   }
+   * });
+   * ```
+   *
+   * @param {function} callback invoked when the toState is invalid
+   *   This function receives the (invalid) toState, the fromState, and an injector.
+   *   The function may optionally return a [[TargetState]] or a Promise for a TargetState.
+   *   If one is returned, it is treated as a redirect.
+   *
+   * @returns a function which deregisters the callback
+   */
+  onInvalid(callback: Function): any;
+  /**
+   * Reloads the current state
+   *
+   * A method that force reloads the current state, or a partial state hierarchy.
+   * All resolves are re-resolved, and components reinstantiated.
+   *
+   * #### Example:
+   * ```js
+   * let app angular.module('app', ['ui.router']);
+   *
+   * app.controller('ctrl', function ($scope, $state) {
+   *   $scope.reload = function(){
+   *     $state.reload();
+   *   }
+   * });
+   * ```
+   *
+   * Note: `reload()` is just an alias for:
+   *
+   * ```js
+   * $state.transitionTo($state.current, $state.params, {
+   *   reload: true, inherit: false
+   * });
+   * ```
+   *
+   * @param reloadState A state name or a state object.
+   *    If present, this state and all its children will be reloaded, but ancestors will not reload.
+   *
+   * #### Example:
+   * ```js
+   * //assuming app application consists of 3 states: 'contacts', 'contacts.detail', 'contacts.detail.item'
+   * //and current state is 'contacts.detail.item'
+   * let app angular.module('app', ['ui.router']);
+   *
+   * app.controller('ctrl', function ($scope, $state) {
+   *   $scope.reload = function(){
+   *     //will reload 'contact.detail' and nested 'contact.detail.item' states
+   *     $state.reload('contact.detail');
+   *   }
+   * });
+   * ```
+   *
+   * @returns A promise representing the state of the new transition. See [[StateService.go]]
+   */
+  reload(reloadState: any): any;
+  /**
+   * Transition to a different state and/or parameters
+   *
+   * Convenience method for transitioning to a new state.
+   *
+   * `$state.go` calls `$state.transitionTo` internally but automatically sets options to
+   * `{ location: true, inherit: true, relative: router.globals.$current, notify: true }`.
+   * This allows you to use either an absolute or relative `to` argument (because of `relative: router.globals.$current`).
+   * It also allows you to specify * only the parameters you'd like to update, while letting unspecified parameters
+   * inherit from the current parameter values (because of `inherit: true`).
+   *
+   * #### Example:
+   * ```js
+   * let app = angular.module('app', ['ui.router']);
+   *
+   * app.controller('ctrl', function ($scope, $state) {
+   *   $scope.changeState = function () {
+   *     $state.go('contact.detail');
+   *   };
+   * });
+   * ```
+   *
+   * @param to Absolute state name, state object, or relative state path (relative to current state).
+   *
+   * Some examples:
+   *
+   * - `$state.go('contact.detail')` - will go to the `contact.detail` state
+   * - `$state.go('^')` - will go to the parent state
+   * - `$state.go('^.sibling')` - if current state is `home.child`, will go to the `home.sibling` state
+   * - `$state.go('.child.grandchild')` - if current state is home, will go to the `home.child.grandchild` state
+   *
+   * @param params A map of the parameters that will be sent to the state, will populate $stateParams.
+   *
+   *    Any parameters that are not specified will be inherited from current parameter values (because of `inherit: true`).
+   *    This allows, for example, going to a sibling state that shares parameters defined by a parent state.
+   *
+   * @param options Transition options
+   *
+   * @returns {promise} A promise representing the state of the new transition.
+   */
+  go(to: any, params: any, options: any): Promise<any>;
+  /**
+   * Creates a [[TargetState]]
+   *
+   * This is a factory method for creating a TargetState
+   *
+   * This may be returned from a Transition Hook to redirect a transition, for example.
+   */
+  target(identifier: any, params: any, options?: {}): TargetState;
+  getCurrentPath(): PathNode[];
+  /**
+   * Low-level method for transitioning to a new state.
+   *
+   * The [[go]] method (which uses `transitionTo` internally) is recommended in most situations.
+   *
+   * #### Example:
+   * ```js
+   * let app = angular.module('app', ['ui.router']);
+   *
+   * app.controller('ctrl', function ($scope, $state) {
+   *   $scope.changeState = function () {
+   *     $state.transitionTo('contact.detail');
+   *   };
+   * });
+   * ```
+   *
+   * @param to State name or state object.
+   * @param toParams A map of the parameters that will be sent to the state,
+   *      will populate $stateParams.
+   * @param options Transition options
+   *
+   * @returns A promise representing the state of the new transition. See [[go]]
+   */
+  transitionTo(to: any, toParams?: {}, options?: {}): any;
+  /**
+   * Checks if the current state *is* the provided state
+   *
+   * Similar to [[includes]] but only checks for the full state name.
+   * If params is supplied then it will be tested for strict equality against the current
+   * active params object, so all params must match with none missing and no extras.
+   *
+   * #### Example:
+   * ```js
+   * $state.$current.name = 'contacts.details.item';
+   *
+   * // absolute name
+   * $state.is('contact.details.item'); // returns true
+   * $state.is(contactDetailItemStateObject); // returns true
+   * ```
+   *
+   * // relative name (. and ^), typically from a template
+   * // E.g. from the 'contacts.details' template
+   * ```html
+   * <div ng-class="{highlighted: $state.is('.item')}">Item</div>
+   * ```
+   *
+   * @param stateOrName The state name (absolute or relative) or state object you'd like to check.
+   * @param params A param object, e.g. `{sectionId: section.id}`, that you'd like
+   * to test against the current active state.
+   * @param options An options object. The options are:
+   *   - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will
+   *     test relative to `options.relative` state (or name).
+   *
+   * @returns Returns true if it is the state.
+   */
+  is(stateOrName: any, params: any, options: any): boolean;
+  /**
+   * Checks if the current state *includes* the provided state
+   *
+   * A method to determine if the current active state is equal to or is the child of the
+   * state stateName. If any params are passed then they will be tested for a match as well.
+   * Not all the parameters need to be passed, just the ones you'd like to test for equality.
+   *
+   * #### Example when `$state.$current.name === 'contacts.details.item'`
+   * ```js
+   * // Using partial names
+   * $state.includes("contacts"); // returns true
+   * $state.includes("contacts.details"); // returns true
+   * $state.includes("contacts.details.item"); // returns true
+   * $state.includes("contacts.list"); // returns false
+   * $state.includes("about"); // returns false
+   * ```
+   *
+   * #### Glob Examples when `* $state.$current.name === 'contacts.details.item.url'`:
+   * ```js
+   * $state.includes("*.details.*.*"); // returns true
+   * $state.includes("*.details.**"); // returns true
+   * $state.includes("**.item.**"); // returns true
+   * $state.includes("*.details.item.url"); // returns true
+   * $state.includes("*.details.*.url"); // returns true
+   * $state.includes("*.details.*"); // returns false
+   * $state.includes("item.**"); // returns false
+   * ```
+   *
+   * @param stateOrName A partial name, relative name, glob pattern,
+   *   or state object to be searched for within the current state name.
+   * @param params A param object, e.g. `{sectionId: section.id}`,
+   *   that you'd like to test against the current active state.
+   * @param options An options object. The options are:
+   *   - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will
+   *     test relative to `options.relative` state (or name).
+   *
+   * @returns {boolean} Returns true if it does include the state
+   */
+  includes(stateOrName: any, params: any, options: any): boolean;
+  /**
+   * Generates a URL for a state and parameters
+   *
+   * Returns the url for the given state populated with the given params.
+   *
+   * #### Example:
+   * ```js
+   * expect($state.href("about.person", { person: "bob" })).toEqual("/about/bob");
+   * ```
+   *
+   * @param stateOrName The state name or state object you'd like to generate a url from.
+   * @param params An object of parameter values to fill the state's required parameters.
+   * @param options Options object. The options are:
+   *
+   * @returns {string} compiled state url
+   */
+  href(stateOrName: any, params: any, options: any): string;
+  /**
+   * Sets or gets the default [[transitionTo]] error handler.
+   *
+   * The error handler is called when a [[Transition]] is rejected or when any error occurred during the Transition.
+   * This includes errors caused by resolves and transition hooks.
+   *
+   * Note:
+   * This handler does not receive certain Transition rejections.
+   * Redirected and Ignored Transitions are not considered to be errors by [[StateService.transitionTo]].
+   *
+   * The built-in default error handler logs the error to the console.
+   *
+   * You can provide your own custom handler.
+   *
+   * #### Example:
+   * ```js
+   * stateService.defaultErrorHandler(function() {
+   *   // Do not log transitionTo errors
+   * });
+   * ```
+   *
+   * @param handler a global error handler function
+   * @returns the current global error handler
+   */
+  defaultErrorHandler(handler: any): any;
+  get(stateOrName: any, base: any, ...args: any[]): any;
+  /**
+   * Lazy loads a state
+   *
+   * Explicitly runs a state's [[StateDeclaration.lazyLoad]] function.
+   *
+   * @param stateOrName the state that should be lazy loaded
+   * @param transition the optional Transition context to use (if the lazyLoad function requires an injector, etc)
+   * Note: If no transition is provided, a noop transition is created using the from the current state to the current state.
+   * This noop transition is not actually run.
+   *
+   * @returns a promise to lazy load
+   */
+  lazyLoad(stateOrName: any, transition: any): any;
+}
+import { TargetState } from "./target-state.js";
+import { PathNode } from "../path/path-node.js";

package/@types/router/state/target-state.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Encapsulate the target (destination) state/params/options of a [[Transition]].
+ *
+ * This class is frequently used to redirect a transition to a new destination.
+ *
+ * See:
+ *
+ * - [[HookResult]]
+ * - [[TransitionHookFn]]
+ * - [[TransitionService.onStart]]
+ *
+ * To create a `TargetState`, use [[StateService.target]].
+ *
+ * ---
+ *
+ * This class wraps:
+ *
+ * 1) an identifier for a state
+ * 2) a set of parameters
+ * 3) and transition options
+ * 4) the registered state object (the [[StateDeclaration]])
+ *
+ * Many ng-router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
+ * either be a *state object* (a [[StateDeclaration]] or [[StateObject]]) or a *state name* (a string).
+ * The `TargetState` class normalizes those options.
+ *
+ * A `TargetState` may be valid (the state being targeted exists in the registry)
+ * or invalid (the state being targeted is not registered).
+ */
+export class TargetState {
+  /**
+   * The TargetState constructor
+   *
+   * Note: Do not construct a `TargetState` manually.
+   * To create a `TargetState`, use the [[StateService.target]] factory method.
+   *
+   * @param _stateRegistry The StateRegistry to use to look up the _definition
+   * @param _identifier An identifier for a state.
+   *    Either a fully-qualified state name, or the object used to define the state.
+   * @param _params Parameters for the target state
+   * @param _options Transition options.
+   *
+   * @internal
+   */
+  constructor(
+    _stateRegistry: any,
+    _identifier: any,
+    _params: any,
+    _options: any,
+  );
+  _stateRegistry: any;
+  _identifier: any;
+  _params: any;
+  _options: any;
+  _definition: any;
+  /** The name of the state this object targets */
+  name(): any;
+  /** The identifier used when creating this TargetState */
+  identifier(): any;
+  /** The target parameter values */
+  params(): any;
+  /** The internal state object (if it was found) */
+  $state(): any;
+  /** The internal state declaration (if it was found) */
+  state(): any;
+  /** The target options */
+  options(): any;
+  /** True if the target state was found */
+  exists(): boolean;
+  /** True if the object is valid */
+  valid(): boolean;
+  /** If the object is invalid, returns the reason why */
+  error(): string;
+  toString(): string;
+  /**
+   * Returns a copy of this TargetState which targets a different state.
+   * The new TargetState has the same parameter values and transition options.
+   *
+   * @param state The new state that should be targeted
+   */
+  withState(state: any): TargetState;
+  /**
+   * Returns a copy of this TargetState, using the specified parameter values.
+   *
+   * @param params the new parameter values to use
+   * @param replace When false (default) the new parameter values will be merged with the current values.
+   *                When true the parameter values will be used instead of the current values.
+   */
+  withParams(params: any, replace?: boolean): TargetState;
+  /**
+   * Returns a copy of this TargetState, using the specified Transition Options.
+   *
+   * @param options the new options to use
+   * @param replace When false (default) the new options will be merged with the current options.
+   *                When true the options will be used instead of the current options.
+   */
+  withOptions(options: any, replace?: boolean): TargetState;
+}
+export namespace TargetState {
+  /** Returns true if the object has a state property that might be a state or state name */
+  function isDef(obj: any): boolean;
+}

package/@types/router/state/views.d.ts

@@ -0,0 +1,58 @@
+export function getViewConfigFactory(): (path: any, view: any) => ViewConfig;
+/**
+ * This is a [[StateBuilder.builder]] function for angular1 `views`.
+ *
+ * When the [[StateBuilder]] builds a [[StateObject]] object from a raw [[StateDeclaration]], this builder
+ * handles the `views` property with logic specific to @uirouter/angularjs (ng1).
+ *
+ * If no `views: {}` property exists on the [[StateDeclaration]], then it creates the `views` object
+ * and applies the state-level configuration to a view named `$default`.
+ *
+ */
+export function ng1ViewsBuilder(state: any): {};
+export class ViewConfig {
+  /**
+   * Normalizes a view's name from a state.views configuration block.
+   *
+   * This should be used by a framework implementation to calculate the values for
+   * [[_ViewDeclaration.$ngViewName]] and [[_ViewDeclaration.$ngViewContextAnchor]].
+   *
+   * @param context the context object (state declaration) that the view belongs to
+   * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
+   *
+   * @returns the normalized ngViewName and ngViewContextAnchor that the view targets
+   */
+  static normalizeUIViewTarget(
+    context: any,
+    rawViewName?: string,
+  ): {
+    ngViewName: string;
+    ngViewContextAnchor: string;
+  };
+  /**
+   * @param {Array<import('../path/path-node.js').PathNode>} path
+   * @param viewDecl
+   * @param {import('../template-factory.js').TemplateFactoryProvider} factory
+   */
+  constructor(
+    path: Array<import("../path/path-node.js").PathNode>,
+    viewDecl: any,
+    factory: import("../template-factory.js").TemplateFactoryProvider,
+  );
+  path: import("../path/path-node.js").PathNode[];
+  viewDecl: any;
+  factory: import("../template-factory.js").TemplateFactoryProvider;
+  component: any;
+  template: any;
+  /** @type {Number} */ $id: number;
+  loaded: boolean;
+  getTemplate: (ngView: any, context: any) => any;
+  load(): Promise<this>;
+  controller: any;
+  /**
+   * Gets the controller for a view configuration.
+   *
+   * @returns {Function|Promise.<Function>} Returns a controller, or a promise that resolves to a controller.
+   */
+  getController(context: any): Function | Promise<Function>;
+}

package/@types/router/state-filters.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `isState` Filter: truthy if the current state is the parameter
+ *
+ * Translates to [[StateService.is]] `$state.is("stateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'stateName' | isState">show if state is 'stateName'</div>
+ * ```
+ *
+ * @param {import('./state/state-service.js').StateProvider} $state
+ * @returns {import('../interface.ts').FilterFn}
+ */
+export function $IsStateFilter(
+  $state: import("./state/state-service.js").StateProvider,
+): import("../interface.ts").FilterFn;
+export namespace $IsStateFilter {
+  let $inject: string[];
+}
+/**
+ * `includedByState` Filter: truthy if the current state includes the parameter
+ *
+ * Translates to [[StateService.includes]]` $state.is("fullOrPartialStateName")`.
+ *
+ * #### Example:
+ * ```html
+ * <div ng-if="'fullOrPartialStateName' | includedByState">show if state includes 'fullOrPartialStateName'</div>
+ * ```
+ *
+ * @param {import('./state/state-service.js').StateProvider} $state
+ * @returns {import('../interface.ts').FilterFn}
+ */
+export function $IncludedByStateFilter(
+  $state: import("./state/state-service.js").StateProvider,
+): import("../interface.ts").FilterFn;
+export namespace $IncludedByStateFilter {
+  let $inject_1: string[];
+  export { $inject_1 as $inject };
+}