@angular-wave/angular.ts 0.0.35 → 0.0.37

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

@@ -0,0 +1,123 @@
+/**
+ * The Angular 1 `StateProvider`
+ *
+ * The `$stateProvider` works similar to Angular's v1 router, but it focuses purely
+ * on state.
+ *
+ * A state corresponds to a "place" in the application in terms of the overall UI and
+ * navigation. A state describes (via the controller / template / view properties) what
+ * the UI looks like and does at that place.
+ *
+ * States often have things in common, and the primary way of factoring out these
+ * commonalities in this model is via the state hierarchy, i.e. parent/child states aka
+ * nested states.
+ *
+ * The `$stateProvider` provides interfaces to declare these states for your app.
+ */
+export class StateProvider {
+  constructor(stateRegistry: any, stateService: any);
+  stateRegistry: any;
+  stateService: any;
+  /**
+   * 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 ui-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 config object
+   *   (template, controller) for the view. Even when you don't use the views object
+   *   explicitly on a state config, 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 (config, name) {
+   *     let autoName = (state.name + '.' + name).replace('.', '/');
+   *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
+   *     result[name] = config;
+   *   });
+   *   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 config object.
+   *   - `{object}` - super - The original builder function.
+   *
+   * @return {object} $stateProvider - $stateProvider instance
+   */
+  decorator(name: string, func: object): object;
+  /**
+   *
+   * @param {angular.Ng1StateDeclaration} definition
+   * @returns {StateProvider}
+   */
+  state(definition: angular.Ng1StateDeclaration): StateProvider;
+  /**
+   * Registers an invalid state handler
+   *
+   * This is a passthrough to [[StateService.onInvalid]] for ng1.
+   */
+  onInvalid(callback: any): any;
+}

package/types/router/template-factory.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @typedef BindingTuple
+ * @property {string} name
+ * @property {string} type
+ */
+/**
+ * Service which manages loading of templates from a ViewConfig.
+ */
+export class TemplateFactory {
+  /** @type {boolean} */
+  _useHttp: boolean;
+  $get: (
+    | string
+    | ((
+        $http: angular.IHttpService,
+        $templateCache: angular.ITemplateCacheService,
+        $templateRequest: angular.ITemplateRequestService,
+        $q: angular.IQService,
+        $injector: angular.auto.IInjectorService,
+      ) => this)
+  )[];
+  $templateRequest: angular.ITemplateRequestService;
+  $http: angular.IHttpService;
+  $templateCache: angular.ITemplateCacheService;
+  $q: angular.IQService;
+  $injector: angular.auto.IInjectorService;
+  /**
+   * Forces the provider to use $http service directly
+   * @param {boolean} value
+   */
+  useHttpService(value: boolean): void;
+  /**
+   * Creates a template from a configuration object.
+   *
+   * @param config Configuration object for which to load a template.
+   * The following properties are search in the specified order, and the first one
+   * that is defined is used to create the template:
+   *
+   * @param {angular.Ng1ViewDeclaration} config
+   * @param {any} params  Parameters to pass to the template function.
+   * @param {angular.ResolveContext} context The resolve context associated with the template's view
+   *
+   * @return {string|object}  The template html as a string, or a promise for
+   * that string,or `null` if no template is configured.
+   */
+  fromConfig(
+    config: angular.Ng1ViewDeclaration,
+    params: any,
+    context: angular.ResolveContext,
+  ): string | object;
+  /**
+   * Creates a template from a string or a function returning a string.
+   *
+   * @param {string | Function} template html template as a string or function that returns an html template as a string.
+   * @param {angular.RawParams} [params] Parameters to pass to the template function.
+   *
+   * @return {string|object} The template html as a string, or a promise for that
+   * string.
+   */
+  fromString(
+    template: string | Function,
+    params?: angular.RawParams,
+  ): string | object;
+  /**
+   * Loads a template from the a URL via `$http` and `$templateCache`.
+   *
+   * @param {string|Function} url url of the template to load, or a function
+   * that returns a url.
+   * @param {Object} params Parameters to pass to the url function.
+   * @return {string|Promise.<string>} The template html as a string, or a promise
+   * for that string.
+   */
+  fromUrl(url: string | Function, params: any): string | Promise<string>;
+  /**
+   * Creates a template by invoking an injectable provider function.
+   *
+   * @param {angular.IInjectable} provider Function to invoke via `locals`
+   * @param {Function} injectFn a function used to invoke the template provider
+   * @param {angular.ResolveContext} context
+   * @return {string|Promise.<string>} The template html as a string, or a promise
+   * for that string.
+   */
+  fromProvider(
+    provider: angular.IInjectable,
+    params: any,
+    context: angular.ResolveContext,
+  ): string | Promise<string>;
+  /**
+   * Creates a component's template by invoking an injectable provider function.
+   *
+   * @param {angular.IInjectable} provider Function to invoke via `locals`
+   * @param {Function} injectFn a function used to invoke the template provider
+   * @return {string} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
+   */
+  fromComponentProvider(
+    provider: angular.IInjectable,
+    params: any,
+    context: any,
+  ): string;
+  /**
+   * Creates a template from a component's name
+   *
+   * This implements route-to-component.
+   * It works by retrieving the component (directive) metadata from the injector.
+   * It analyses the component's bindings, then constructs a template that instantiates the component.
+   * The template wires input and output bindings to resolves or from the parent component.
+   *
+   * @param {angular.IAugmentedJQuery} ngView {object} The parent ui-view (for binding outputs to callbacks)
+   * @param {angular.ResolveContext} context The ResolveContext (for binding outputs to callbacks returned from resolves)
+   * @param {string} component {string} Component's name in camel case.
+   * @param {any} [bindings] An object defining the component's bindings: {foo: '<'}
+   * @return {string} The template as a string: "<component-name input1='::$resolve.foo'></component-name>".
+   */
+  makeComponentTemplate(
+    ngView: angular.IAugmentedJQuery,
+    context: angular.ResolveContext,
+    component: string,
+    bindings?: any,
+  ): string;
+}
+export type BindingTuple = {
+  name: string;
+  type: string;
+};

package/types/router/transition/hook-builder.d.ts

@@ -0,0 +1,40 @@
+/**
+ * This class returns applicable TransitionHooks for a specific Transition instance.
+ *
+ * Hooks ([[RegisteredHook]]) may be registered globally, e.g., $transitions.onEnter(...), or locally, e.g.
+ * myTransition.onEnter(...).  The HookBuilder finds matching RegisteredHooks (where the match criteria is
+ * determined by the type of hook)
+ *
+ * The HookBuilder also converts RegisteredHooks objects to TransitionHook objects, which are used to run a Transition.
+ *
+ * The HookBuilder constructor is given the $transitions service and a Transition instance.  Thus, a HookBuilder
+ * instance may only be used for one specific Transition object. (side note: the _treeChanges accessor is private
+ * in the Transition class, so we must also provide the Transition's _treeChanges)
+ */
+export class HookBuilder {
+  constructor(transition: any);
+  transition: any;
+  buildHooksForPhase(phase: any): any;
+  /**
+   * Returns an array of newly built TransitionHook objects.
+   *
+   * - Finds all RegisteredHooks registered for the given `hookType` which matched the transition's [[TreeChanges]].
+   * - Finds [[PathNode]] (or `PathNode[]`) to use as the TransitionHook context(s)
+   * - For each of the [[PathNode]]s, creates a TransitionHook
+   *
+   * @param hookType the type of the hook registration function, e.g., 'onEnter', 'onFinish'.
+   */
+  buildHooks(hookType: any): any;
+  /**
+   * Finds all RegisteredHooks from:
+   * - The Transition object instance hook registry
+   * - The TransitionService ($transitions) global hook registry
+   *
+   * which matched:
+   * - the eventType
+   * - the matchCriteria (to, from, exiting, retained, entering)
+   *
+   * @returns an array of matched [[RegisteredHook]]s
+   */
+  getMatchingHooks(hookType: any, treeChanges: any, transition: any): any;
+}

package/types/router/transition/hook-registry.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Determines if the given state matches the matchCriteria
+ *
+ * @internal
+ *
+ * @param state a State Object to test against
+ * @param criterion
+ * - If a string, matchState uses the string as a glob-matcher against the state name
+ * - If an array (of strings), matchState uses each string in the array as a glob-matchers against the state name
+ *   and returns a positive match if any of the globs match.
+ * - If a function, matchState calls the function with the state and returns true if the function's result is truthy.
+ * @returns {boolean}
+ */
+export function matchState(
+  state: any,
+  criterion: any,
+  transition: any,
+): boolean;
+/** Return a registration function of the requested type. */
+export function makeEvent(
+  registry: any,
+  transitionService: any,
+  eventType: any,
+): (matchObject: any, callback: any, options?: {}) => any;
+/**
+ * The registration data for a registered transition hook
+ */
+export class RegisteredHook {
+  constructor(
+    tranSvc: any,
+    eventType: any,
+    callback: any,
+    matchCriteria: any,
+    removeHookFromRegistry: any,
+    options?: {},
+  );
+  tranSvc: any;
+  eventType: any;
+  callback: any;
+  matchCriteria: any;
+  removeHookFromRegistry: any;
+  invokeCount: number;
+  _deregistered: boolean;
+  priority: any;
+  bind: any;
+  invokeLimit: any;
+  /**
+   * Gets the matching [[PathNode]]s
+   *
+   * Given an array of [[PathNode]]s, and a [[HookMatchCriterion]], returns an array containing
+   * the [[PathNode]]s that the criteria matches, or `null` if there were no matching nodes.
+   *
+   * Returning `null` is significant to distinguish between the default
+   * "match-all criterion value" of `true` compared to a `() => true` function,
+   * when the nodes is an empty array.
+   *
+   * This is useful to allow a transition match criteria of `entering: true`
+   * to still match a transition, even when `entering === []`.  Contrast that
+   * with `entering: (state) => true` which only matches when a state is actually
+   * being entered.
+   */
+  _matchingNodes(nodes: any, criterion: any, transition: any): any;
+  /**
+   * Gets the default match criteria (all `true`)
+   *
+   * Returns an object which has all the criteria match paths as keys and `true` as values, i.e.:
+   *
+   * ```js
+   * {
+   *   to: true,
+   *   from: true,
+   *   entering: true,
+   *   exiting: true,
+   *   retained: true,
+   * }
+   */
+  _getDefaultMatchCriteria(): any;
+  /**
+   * Gets matching nodes as [[IMatchingNodes]]
+   *
+   * Create a IMatchingNodes object from the TransitionHookTypes that is roughly equivalent to:
+   *
+   * ```js
+   * let matches: IMatchingNodes = {
+   *   to:       _matchingNodes([tail(treeChanges.to)],   mc.to),
+   *   from:     _matchingNodes([tail(treeChanges.from)], mc.from),
+   *   exiting:  _matchingNodes(treeChanges.exiting,      mc.exiting),
+   *   retained: _matchingNodes(treeChanges.retained,     mc.retained),
+   *   entering: _matchingNodes(treeChanges.entering,     mc.entering),
+   * };
+   * ```
+   */
+  _getMatchingNodes(treeChanges: any, transition: any): any;
+  /**
+   * Determines if this hook's [[matchCriteria]] match the given [[TreeChanges]]
+   *
+   * @returns an IMatchingNodes object, or null. If an IMatchingNodes object is returned, its values
+   * are the matching [[PathNode]]s for each [[HookMatchCriterion]] (to, from, exiting, retained, entering)
+   */
+  matches(treeChanges: any, transition: any): any;
+  deregister(): void;
+}

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

@@ -0,0 +1,11 @@
+export namespace TransitionHookPhase {
+  let CREATE: number;
+  let BEFORE: number;
+  let RUN: number;
+  let SUCCESS: number;
+  let ERROR: number;
+}
+export namespace TransitionHookScope {
+  let TRANSITION: number;
+  let STATE: number;
+}

package/types/router/transition/reject-factory.d.ts

@@ -0,0 +1,42 @@
+/**
+ * An object for Transition Rejection reasons.
+ */
+export type RejectType = number;
+export namespace RejectType {
+  let SUPERSEDED: number;
+  let ABORTED: number;
+  let INVALID: number;
+  let IGNORED: number;
+  let ERROR: number;
+}
+export class Rejection {
+  /** Returns a Rejection due to transition superseded */
+  static superseded(detail: any, options: any): Rejection;
+  /** Returns a Rejection due to redirected transition */
+  static redirected(detail: any): Rejection;
+  /** Returns a Rejection due to invalid transition */
+  static invalid(detail: any): Rejection;
+  /** Returns a Rejection due to ignored transition */
+  static ignored(detail: any): Rejection;
+  /** Returns a Rejection due to aborted transition */
+  static aborted(detail: any): Rejection;
+  /** Returns a Rejection due to aborted transition */
+  static errored(detail: any): Rejection;
+  /**
+   * Returns a Rejection
+   *
+   * Normalizes a value as a Rejection.
+   * If the value is already a Rejection, returns it.
+   * Otherwise, wraps and returns the value as a Rejection (Rejection type: ERROR).
+   *
+   * @returns `detail` if it is already a `Rejection`, else returns an ERROR Rejection.
+   */
+  static normalize(detail: any): any;
+  constructor(type: any, message: any, detail: any);
+  $id: number;
+  type: any;
+  message: any;
+  detail: any;
+  toString(): string;
+  toPromise(): any;
+}

package/types/router/transition/transition-event-type.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This class defines a type of hook, such as `onBefore` or `onEnter`.
+ * Plugins can define custom hook types, such as sticky states does for `onInactive`.
+ */
+export class TransitionEventType {
+  constructor(
+    name: any,
+    hookPhase: any,
+    hookOrder: any,
+    criteriaMatchPath: any,
+    reverseSort?: boolean,
+    getResultHandler?: (hook: any) => (result: any) => any,
+    getErrorHandler?: () => (error: any) => any,
+    synchronous?: boolean,
+  );
+  name: any;
+  hookPhase: any;
+  hookOrder: any;
+  criteriaMatchPath: any;
+  reverseSort: boolean;
+  getResultHandler: (hook: any) => (result: any) => any;
+  getErrorHandler: () => (error: any) => any;
+  synchronous: boolean;
+}

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

@@ -0,0 +1,86 @@
+export class TransitionHook {
+  /**
+   * Chains together an array of TransitionHooks.
+   *
+   * Given a list of [[TransitionHook]] objects, chains them together.
+   * Each hook is invoked after the previous one completes.
+   *
+   * #### Example:
+   * ```js
+   * var hooks: TransitionHook[] = getHooks();
+   * let promise: Promise<any> = TransitionHook.chain(hooks);
+   *
+   * promise.then(handleSuccess, handleError);
+   * ```
+   *
+   * @param hooks the list of hooks to chain together
+   * @param waitFor if provided, the chain is `.then()`'ed off this promise
+   * @returns a `Promise` for sequentially invoking the hooks (in order)
+   */
+  static chain(hooks: any, waitFor: any): any;
+  /**
+   * Invokes all the provided TransitionHooks, in order.
+   * Each hook's return value is checked.
+   * If any hook returns a promise, then the rest of the hooks are chained off that promise, and the promise is returned.
+   * If no hook returns a promise, then all hooks are processed synchronously.
+   *
+   * @param hooks the list of TransitionHooks to invoke
+   * @param doneCallback a callback that is invoked after all the hooks have successfully completed
+   *
+   * @returns a promise for the async result, or the result of the callback
+   */
+  static invokeHooks(hooks: any, doneCallback: any): any;
+  /**
+   * Run all TransitionHooks, ignoring their return value.
+   */
+  static runAllHooks(hooks: any): void;
+  constructor(
+    transition: any,
+    stateContext: any,
+    registeredHook: any,
+    options: any,
+  );
+  transition: any;
+  stateContext: any;
+  registeredHook: any;
+  options: any;
+  isSuperseded: () => boolean;
+  type: any;
+  logError(err: any): void;
+  invokeHook(): any;
+  /**
+   * This method handles the return value of a Transition Hook.
+   *
+   * A hook can return false (cancel), a TargetState (redirect),
+   * or a promise (which may later resolve to false or a redirect)
+   *
+   * This also handles "transition superseded" -- when a new transition
+   * was started while the hook was still running
+   */
+  handleHookResult(result: any): any;
+  /**
+   * Return a Rejection promise if the transition is no longer current due
+   * a new transition has started and superseded this one.
+   */
+  getNotCurrentRejection(): any;
+  toString(): string;
+}
+export namespace TransitionHook {
+  /**
+   * These GetResultHandler(s) are used by [[invokeHook]] below
+   * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])
+   */
+  function HANDLE_RESULT(hook: any): (result: any) => any;
+  /**
+   * If the result is a promise rejection, log it.
+   * Otherwise, ignore the result.
+   */
+  function LOG_REJECTED_RESULT(hook: any): (result: any) => any;
+  /**
+   * These GetErrorHandler(s) are used by [[invokeHook]] below
+   * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
+   */
+  function LOG_ERROR(hook: any): (error: any) => any;
+  function REJECT_ERROR(): (error: any) => any;
+  function THROW_ERROR(): (error: any) => never;
+}

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

@@ -0,0 +1,115 @@
+export namespace defaultTransOpts {
+  let location: boolean;
+  let relative: any;
+  let inherit: boolean;
+  let notify: boolean;
+  let reload: boolean;
+  let supercede: boolean;
+  let custom: {};
+  function current(): any;
+  let source: string;
+}
+/**
+ * This class provides services related to Transitions.
+ *
+ * - Most importantly, it allows global Transition Hooks to be registered.
+ * - It allows the default transition error handler to be set.
+ * - It also has a factory function for creating new [[Transition]] objects, (used internally by the [[StateService]]).
+ *
+ * At bootstrap, [[UIRouter]] creates a single instance (singleton) of this class.
+ *
+ * This API is located at `router.transitionService` ([[UIRouter.transitionService]])
+ */
+export class TransitionService {
+  static $inject: string[];
+  /**
+   * @param {import('../globals').UIRouterGlobals} globals
+   */
+  constructor(globals: import("../globals").UIRouterGlobals, viewService: any);
+  _transitionCount: number;
+  /** The transition hook types, such as `onEnter`, `onStart`, etc */
+  _eventTypes: any[];
+  /** @internal The registered transition hooks */
+  _registeredHooks: {};
+  /** The  paths on a criteria object */
+  _criteriaPaths: {};
+  globals: import("../globals").UIRouterGlobals;
+  $view: any;
+  _deregisterHookFns: {};
+  _pluginapi: any;
+  $get: (
+    | string
+    | ((
+        stateService: any,
+        urlService: any,
+        stateRegistry: any,
+        viewService: any,
+      ) => this)
+  )[];
+  /**
+   * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
+   *
+   * Registers a transition lifecycle hook, which is invoked during transition construction.
+   *
+   * This low level hook should only be used by plugins.
+   * This can be a useful time for plugins to add resolves or mutate the transition as needed.
+   * The Sticky States plugin uses this hook to modify the treechanges.
+   *
+   * ### Lifecycle
+   *
+   * `onCreate` hooks are invoked *while a transition is being constructed*.
+   *
+   * ### Return value
+   *
+   * The hook's return value is ignored
+   *
+   * @internal
+   * @param criteria defines which Transitions the Hook should be invoked for.
+   * @param callback the hook function which will be invoked.
+   * @param options the registration options
+   * @returns a function which deregisters the hook.
+   */
+  /**
+   * Creates a new [[Transition]] object
+   *
+   * This is a factory function for creating new Transition objects.
+   * It is used internally by the [[StateService]] and should generally not be called by application code.
+   *
+   * @internal
+   * @param fromPath the path to the current state (the from state)
+   * @param targetState the target state (destination)
+   * @returns a Transition
+   */
+  create(fromPath: any, targetState: any): Transition;
+  _defineCoreEvents(): void;
+  _defineCorePaths(): void;
+  _defineEvent(
+    name: any,
+    hookPhase: any,
+    hookOrder: any,
+    criteriaMatchPath: any,
+    reverseSort?: boolean,
+    getResultHandler?: (hook: any) => (result: any) => any,
+    getErrorHandler?: () => (error: any) => any,
+    synchronous?: boolean,
+  ): void;
+  _getEvents(phase: any): any[];
+  /**
+   * Adds a Path to be used as a criterion against a TreeChanges path
+   *
+   * For example: the `exiting` path in [[HookMatchCriteria]] is a STATE scoped path.
+   * It was defined by calling `defineTreeChangesCriterion('exiting', TransitionHookScope.STATE)`
+   * Each state in the exiting path is checked against the criteria and returned as part of the match.
+   *
+   * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
+   * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
+   * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
+   *
+   * @internal
+   */
+  _definePathType(name: any, hookScope: any): void;
+  _getPathTypes(): {};
+  getHooks(hookName: any): any;
+  _registerCoreTransitionHooks(): void;
+}
+import { Transition } from "./transition";