@angular-wave/angular.ts 0.0.59 → 0.0.61

package/types-back/router/core/transition/transitionHook.d.ts

@@ -1,96 +0,0 @@
-import { TransitionHookOptions, HookResult } from "./interface";
-import { Transition } from "./transition";
-import { TransitionEventType } from "./transitionEventType";
-import { RegisteredHook } from "./hookRegistry";
-import { StateDeclaration } from "../state/interface";
-export declare type GetResultHandler = (hook: TransitionHook) => ResultHandler;
-export declare type GetErrorHandler = (hook: TransitionHook) => ErrorHandler;
-export declare type ResultHandler = (result: HookResult) => Promise<HookResult>;
-export declare type ErrorHandler = (error: any) => Promise<any>;
-export declare class TransitionHook {
-  private transition;
-  private stateContext;
-  private registeredHook;
-  private options;
-  type: TransitionEventType;
-  /**
-   * These GetResultHandler(s) are used by [[invokeHook]] below
-   * Each HookType chooses a GetResultHandler (See: [[TransitionService._defineCoreEvents]])
-   */
-  static HANDLE_RESULT: GetResultHandler;
-  /**
-   * If the result is a promise rejection, log it.
-   * Otherwise, ignore the result.
-   */
-  static LOG_REJECTED_RESULT: GetResultHandler;
-  /**
-   * These GetErrorHandler(s) are used by [[invokeHook]] below
-   * Each HookType chooses a GetErrorHandler (See: [[TransitionService._defineCoreEvents]])
-   */
-  static LOG_ERROR: GetErrorHandler;
-  static REJECT_ERROR: GetErrorHandler;
-  static THROW_ERROR: GetErrorHandler;
-  /**
-   * 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: TransitionHook[], waitFor?: Promise<any>): Promise<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<T>(
-    hooks: TransitionHook[],
-    doneCallback: (result?: HookResult) => T,
-  ): Promise<any> | T;
-  /**
-   * Run all TransitionHooks, ignoring their return value.
-   */
-  static runAllHooks(hooks: TransitionHook[]): void;
-  constructor(
-    transition: Transition,
-    stateContext: StateDeclaration,
-    registeredHook: RegisteredHook,
-    options: TransitionHookOptions,
-  );
-  private isSuperseded;
-  logError(err: any): any;
-  invokeHook(): Promise<HookResult> | void;
-  /**
-   * 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: HookResult): Promise<HookResult>;
-  /**
-   * Return a Rejection promise if the transition is no longer current due
-   * to a stopped router (disposed), or a new transition has started and superseded this one.
-   */
-  private getNotCurrentRejection;
-  toString(): string;
-}

package/types-back/router/core/transition/transitionService.d.ts

@@ -1,253 +0,0 @@
-import {
-  IHookRegistry,
-  TransitionOptions,
-  TransitionHookScope,
-  TransitionHookPhase,
-  TransitionCreateHookFn,
-  HookMatchCriteria,
-  HookRegOptions,
-  PathTypes,
-  PathType,
-  RegisteredHooks,
-  TransitionHookFn,
-  TransitionStateHookFn,
-} from "./interface";
-import { Transition } from "./transition";
-import { RegisteredHook } from "./hookRegistry";
-import { TargetState } from "../state/targetState";
-import { PathNode } from "../path/pathNode";
-import { ViewService } from "../view/view";
-import { Router } from "../router";
-import { TransitionEventType } from "./transitionEventType";
-import { GetResultHandler, GetErrorHandler } from "./transitionHook";
-/**
- * The default [[Transition]] options.
- *
- * Include this object when applying custom defaults:
- * let reloadOpts = { reload: true, notify: true }
- * let options = defaults(theirOpts, customDefaults, defaultOptions);
- */
-export declare let defaultTransOpts: TransitionOptions;
-/**
- * Plugin API for Transition Service
- */
-export interface TransitionServicePluginAPI {
-  /**
-   * 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.
-   */
-  _definePathType(name: string, hookScope: TransitionHookScope): any;
-  /**
-   * Gets a Path definition used as a criterion against a TreeChanges path
-   */
-  _getPathTypes(): PathTypes;
-  /**
-   * Defines a transition hook type and returns a transition hook registration
-   * function (which can then be used to register hooks of this type).
-   */
-  _defineEvent(
-    name: string,
-    hookPhase: TransitionHookPhase,
-    hookOrder: number,
-    criteriaMatchPath: PathType,
-    reverseSort?: boolean,
-    getResultHandler?: GetResultHandler,
-    getErrorHandler?: GetErrorHandler,
-    rejectIfSuperseded?: boolean,
-  ): any;
-  /**
-   * Returns the known event types, such as `onBefore`
-   * If a phase argument is provided, returns only events for the given phase.
-   */
-  _getEvents(phase?: TransitionHookPhase): TransitionEventType[];
-  /** Returns the hooks registered for the given hook name */
-  getHooks(hookName: string): RegisteredHook[];
-}
-/**
- * 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, [[Router]] creates a single instance (singleton) of this class.
- *
- * This API is located at `router.transitionService` ([[Router.transitionService]])
- */
-export declare class TransitionService implements IHookRegistry {
-  /** @internal */
-  _transitionCount: number;
-  /** @internal */
-  $view: ViewService;
-  /** The transition hook types, such as `onEnter`, `onStart`, etc */
-  private _eventTypes;
-  /** @internal The registered transition hooks */
-  _registeredHooks: RegisteredHooks;
-  /** The  paths on a criteria object */
-  private _criteriaPaths;
-  private _router;
-  /** @internal */
-  _pluginapi: TransitionServicePluginAPI;
-  /**
-   * This object has hook de-registration functions for the built-in hooks.
-   * This can be used by third parties libraries that wish to customize the behaviors
-   *
-   * @internal
-   */
-  _deregisterHookFns: {
-    addCoreResolves: Function;
-    ignored: Function;
-    invalid: Function;
-    redirectTo: Function;
-    onExit: Function;
-    onRetain: Function;
-    onEnter: Function;
-    eagerResolve: Function;
-    lazyResolve: Function;
-    resolveAll: Function;
-    loadViews: Function;
-    activateViews: Function;
-    updateGlobals: Function;
-    updateUrl: Function;
-    lazyLoad: Function;
-  };
-  /** @internal */
-  constructor(_router: Router);
-  /**
-   * 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.
-   */
-  onCreate(
-    criteria: HookMatchCriteria,
-    callback: TransitionCreateHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /** @inheritdoc */
-  onBefore(
-    criteria: HookMatchCriteria,
-    callback: TransitionHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /** @inheritdoc */
-  onStart(
-    criteria: HookMatchCriteria,
-    callback: TransitionHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /** @inheritdoc */
-  onExit(
-    criteria: HookMatchCriteria,
-    callback: TransitionStateHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /** @inheritdoc */
-  onRetain(
-    criteria: HookMatchCriteria,
-    callback: TransitionStateHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /** @inheritdoc */
-  onEnter(
-    criteria: HookMatchCriteria,
-    callback: TransitionStateHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /** @inheritdoc */
-  onFinish(
-    criteria: HookMatchCriteria,
-    callback: TransitionHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /** @inheritdoc */
-  onSuccess(
-    criteria: HookMatchCriteria,
-    callback: TransitionHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /** @inheritdoc */
-  onError(
-    criteria: HookMatchCriteria,
-    callback: TransitionHookFn,
-    options?: HookRegOptions,
-  ): Function;
-  /**
-   * dispose
-   * @internal
-   */
-  dispose(router: Router): void;
-  /**
-   * 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: PathNode[], targetState: TargetState): Transition;
-  /** @internal */
-  private _defineCoreEvents;
-  /** @internal */
-  private _defineCorePaths;
-  /** @internal */
-  _defineEvent(
-    name: string,
-    hookPhase: TransitionHookPhase,
-    hookOrder: number,
-    criteriaMatchPath: PathType,
-    reverseSort?: boolean,
-    getResultHandler?: GetResultHandler,
-    getErrorHandler?: GetErrorHandler,
-    synchronous?: boolean,
-  ): void;
-  /** @internal */
-  private _getEvents;
-  /**
-   * 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
-   */
-  private _definePathType;
-  /** @internal */
-  private _getPathTypes;
-  /** @internal */
-  getHooks(hookName: string): RegisteredHook[];
-  /** @internal */
-  private _registerCoreTransitionHooks;
-}

package/types-back/router/core/url/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./interface";
-export * from "./urlMatcher";
-export * from "./urlMatcherFactory";
-export * from "./urlRouter";
-export * from "./urlRule";
-export * from "./urlService";
-export { UrlRules } from "./urlRules";
-export { UrlConfig } from "./urlConfig";

package/types-back/router/core/url/interface.d.ts

@@ -1,169 +0,0 @@
-/**
- * # URL subsystem
- *
- * Contains code related to managing the URL
- *
- * The primary API is found in [[UrlService]], [[UrlService.config]], and [[UrlService.rules]].
- *
- * @packageDocumentation
- * @preferred
- */
-import { LocationConfig } from "../common";
-import { Router } from "../router";
-import {
-  StateDeclaration,
-  StateObject,
-  TargetState,
-  TargetStateDef,
-} from "../state";
-import { UrlMatcher } from "./urlMatcher";
-import { UrlConfig } from "./urlConfig";
-import { UrlRules } from "./urlRules";
-import { UrlService } from "./urlService";
-export interface UrlMatcherCompileConfig {
-  state?: StateDeclaration;
-  strict?: boolean;
-  caseInsensitive?: boolean;
-  decodeParams?: boolean;
-}
-/** @deprecated use [[UrlConfig]] */
-export interface UrlConfigApi extends LocationConfig, UrlMatcherConfig {}
-/** @deprecated use [[UrlConfig]] */
-export interface UrlMatcherConfig {
-  /** See: [[UrlConfig.caseInsensitive]] */ caseInsensitive: UrlConfig["caseInsensitive"];
-  /** See: [[UrlConfig.strictMode]] */ strictMode: UrlConfig["strictMode"];
-  /** See: [[UrlConfig.defaultSquashPolicy]] */ defaultSquashPolicy: UrlConfig["defaultSquashPolicy"];
-  /** See: [[UrlConfig.type]] */ type: UrlConfig["type"];
-}
-/** @deprecated use [[UrlService]] */
-export interface UrlSyncApi {
-  /** See: [[UrlService.sync]] */ sync: UrlService["sync"];
-  /** See: [[UrlService.listen]] */ listen: UrlService["listen"];
-  /** See: [[UrlService.deferIntercept]] */ deferIntercept: UrlService["deferIntercept"];
-}
-/** @deprecated use [[UrlRules]] */
-export interface UrlRulesApi {
-  /** See: [[UrlRules.sort]] */ sort: UrlRules["sort"];
-  /** See: [[UrlRules.when]] */ when: UrlRules["when"];
-  /** See: [[UrlRules.otherwise]] */ otherwise: UrlRules["otherwise"];
-  /** See: [[UrlRules.initial]] */ initial: UrlRules["initial"];
-  /** See: [[UrlRules.rules]] */ rules: UrlRules["rules"];
-  /** See: [[UrlRules.rule]] */ rule: UrlRules["rule"];
-  /** See: [[UrlRules.removeRule]] */ removeRule: UrlRules["removeRule"];
-}
-/**
- * An object containing the three parts of a URL
- */
-export interface UrlParts {
-  path: string;
-  search?: {
-    [key: string]: any;
-  };
-  hash?: string;
-}
-/**
- * A UrlRule match result
- *
- * The result of UrlRouter.match()
- */
-export interface MatchResult {
-  /** The matched value from a [[UrlRule]] */
-  match: any;
-  /** The rule that matched */
-  rule: UrlRule;
-  /** The match result weight */
-  weight: number;
-}
-/**
- * A function that matches the URL for a [[UrlRule]]
- *
- * Implementations should match against the provided [[UrlParts]] and return the matched value (truthy) if the rule matches.
- * If this rule is selected, the matched value is passed to the [[UrlRuleHandlerFn]].
- *
- * @return the matched value, either truthy or falsey
- */
-export interface UrlRuleMatchFn {
-  (url?: UrlParts, router?: Router): any;
-}
-/**
- * Handler invoked when a rule is matched
- *
- * The matched value from the rule's [[UrlRuleMatchFn]] is passed as the first argument
- * The handler should return a string (to redirect), a [[TargetState]]/[[TargetStateDef]], or void
- *
- * If the handler returns a string, the url is replaced with the string.
- * If the handler returns a [[TargetState]], the target state is activated.
- */
-export interface UrlRuleHandlerFn {
-  (
-    matchValue?: any,
-    url?: UrlParts,
-    router?: Router,
-  ): string | TargetState | TargetStateDef | void;
-}
-/** @internal */
-export declare type UrlRuleType =
-  | "STATE"
-  | "URLMATCHER"
-  | "REGEXP"
-  | "RAW"
-  | "OTHER";
-/**
- * The interface for a URL Rule
- *
- * If you are creating a rule for use with [[UrlRules.rule]], it should implement this interface.
- */
-export interface UrlRule {
-  /**
-   * The rule's ID.
-   *
-   * IDs are auto-assigned when the rule is registered, in increasing order.
-   */
-  $id: number;
-  /**
-   * The rule's priority (defaults to 0).
-   *
-   * This can be used to explicitly modify the rule's priority.
-   * Higher numbers are higher priority.
-   */
-  priority: number;
-  /** @internal */
-  _group: number;
-  /** The type of the rule */
-  type: UrlRuleType;
-  /**
-   * This function should match the url and return the match details
-   *
-   * See [[UrlRuleMatchFn]] for details
-   */
-  match: UrlRuleMatchFn;
-  /**
-   * This function is called if the rule matched, and was selected as the "best match".
-   * This function handles the rule match event.
-   *
-   * See [[UrlRuleHandlerFn]] for details
-   */
-  handler: UrlRuleHandlerFn;
-  /**
-   * The priority of a given match.
-   *
-   * Sometimes more than one UrlRule might have matched.
-   * This method is used to choose the best match.
-   *
-   * If multiple rules matched, each rule's `matchPriority` is called with the value from [[match]].
-   * The rule with the highest `matchPriority` has its [[handler]] called.
-   */
-  matchPriority(match: any): number;
-}
-export interface MatcherUrlRule extends UrlRule {
-  type: "URLMATCHER" | "STATE";
-  urlMatcher: UrlMatcher;
-}
-export interface StateRule extends MatcherUrlRule {
-  type: "STATE";
-  state: StateObject;
-}
-export interface RegExpRule extends UrlRule {
-  type: "REGEXP";
-  regexp: RegExp;
-}

package/types-back/router/core/url/urlConfig.d.ts

@@ -1,144 +0,0 @@
-import { Router } from "../router";
-import { ParamTypeDefinition, ParamTypes } from "../params";
-/**
- * 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: [[Router.urlService]], [[URLService.config]])
- */
-export declare class UrlConfig {
-  private router;
-  /** @internal */ paramTypes: ParamTypes;
-  /** @internal */ _decodeParams: boolean;
-  /** @internal */ _isCaseInsensitive: boolean;
-  /** @internal */ _isStrictMode: boolean;
-  /** @internal */ _defaultSquashPolicy: boolean | string;
-  /** @internal */ constructor(/** @internal */ router: Router);
-  /** @internal */ dispose: () => void;
-  /**
-   * Gets the base Href, e.g., `http://localhost/approot/`
-   *
-   * @return the application's base href
-   */
-  baseHref: () => string;
-  /**
-   * Gets or sets the hashPrefix
-   *
-   * This only applies when not running in [[html5Mode]] (pushstate mode)
-   *
-   * If the current url is `http://localhost/app#!/uirouter/path/#anchor`, it returns `!` which is the prefix for the "hashbang" portion.
-   *
-   * @return the hash prefix
-   */
-  hashPrefix: (newprefix?: string) => string;
-  /**
-   * Gets the host, e.g., `localhost`
-   *
-   * @return the protocol
-   */
-  host: () => string;
-  /**
-   * Returns true when running in pushstate mode
-   *
-   * @return true when running in html5 mode (pushstate mode).
-   */
-  html5Mode: () => boolean;
-  /**
-   * Gets the port, e.g., `80`
-   *
-   * @return the port number
-   */
-  port: () => number;
-  /**
-   * Gets the protocol, e.g., `http`
-   *
-   * @return the protocol
-   */
-  protocol: () => string;
-  /**
-   * 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?: boolean): boolean;
-  /**
-   * 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?: boolean | string): string | boolean;
-  /**
-   * 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?: boolean): boolean;
-  /**
-   * 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: string,
-    definition?: ParamTypeDefinition,
-    definitionFn?: () => ParamTypeDefinition,
-  ): any;
-}