@angular-wave/angular.ts 0.0.29 → 0.0.31

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

@@ -1,4 +1,4 @@
-import { UIRouter } from "../router";
+import { Router } from "../router";
 import { ParamTypeDefinition, ParamTypes } from "../params";
 /**
  * An API to customize the URL behavior and retrieve URL configuration
@@ -11,7 +11,7 @@ import { ParamTypeDefinition, ParamTypes } from "../params";
  * 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: [[UIRouter.urlService]], [[URLService.config]])
+ * This API is found at `router.urlService.config` (see: [[Router.urlService]], [[URLService.config]])
  */
 export declare class UrlConfig {
   private router;
@@ -20,7 +20,7 @@ export declare class UrlConfig {
   /** @internal */ _isCaseInsensitive: boolean;
   /** @internal */ _isStrictMode: boolean;
   /** @internal */ _defaultSquashPolicy: boolean | string;
-  /** @internal */ constructor(/** @internal */ router: UIRouter);
+  /** @internal */ constructor(/** @internal */ router: Router);
   /** @internal */ dispose: () => void;
   /**
    * Gets the base Href, e.g., `http://localhost/approot/`

package/types/router/core/url/urlMatcherFactory.d.ts

@@ -2,19 +2,19 @@ import { UrlMatcher } from "./urlMatcher";
 import { Param, ParamType, ParamTypeDefinition } from "../params";
 import { UrlMatcherCompileConfig } from "./interface";
 import { StateDeclaration } from "../state";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 export declare class ParamFactory {
   private router;
   fromConfig(id: string, type: ParamType, state: StateDeclaration): Param;
   fromPath(id: string, type: ParamType, state: StateDeclaration): Param;
   fromSearch(id: string, type: ParamType, state: StateDeclaration): Param;
-  constructor(router: UIRouter);
+  constructor(router: Router);
 }
 /**
  * Factory for [[UrlMatcher]] instances.
  *
  * The factory is available to ng1 services as
- * `$urlMatcherFactory` or ng1 providers as `$urlMatcherFactoryProvider`.
+ * `$urlMatcherFactory` or ng1 providers as `$urlServiceProvider`.
  */
 export declare class UrlMatcherFactory {
   private router;
@@ -22,7 +22,7 @@ export declare class UrlMatcherFactory {
   paramFactory: ParamFactory;
   UrlMatcher: typeof UrlMatcher;
   Param: typeof Param;
-  constructor(/** @internal */ router: UIRouter);
+  constructor(/** @internal */ router: Router);
   /**
    * Creates a [[UrlMatcher]] for the specified pattern.
    *

package/types/router/core/url/urlRouter.d.ts

@@ -1,6 +1,6 @@
 import { UrlMatcher } from "./urlMatcher";
 import { RawParams } from "../params";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 import { UrlRuleFactory } from "./urlRule";
 import { MatchResult, UrlParts, UrlRule, UrlRuleHandlerFn } from "./interface";
 import { TargetState, TargetStateDef } from "../state";
@@ -18,7 +18,7 @@ export declare class UrlRouter {
   urlRuleFactory: UrlRuleFactory;
   /** @internal */ private location;
   /** @internal */
-  constructor(/** @internal */ router: UIRouter);
+  constructor(/** @internal */ router: Router);
   /** Internal API. */
   update(read?: boolean): void;
   /**

package/types/router/core/url/urlRule.d.ts

@@ -1,6 +1,6 @@
 import { StateDeclaration } from "../state";
 import { UrlMatcher } from "./urlMatcher";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 import { StateObject } from "../state/stateObject";
 import {
   UrlRule,
@@ -22,9 +22,9 @@ import {
  * - [[StateObject]]
  */
 export declare class UrlRuleFactory {
-  router: UIRouter;
+  router: Router;
   static isUrlRule: (obj: any) => boolean;
-  constructor(router: UIRouter);
+  constructor(router: Router);
   compile(str: string): UrlMatcher;
   create(
     what:
@@ -47,7 +47,7 @@ export declare class UrlRuleFactory {
    *
    * - matched parameter values ([[RawParams]] from [[UrlMatcher.exec]])
    * - url: the current Url ([[UrlParts]])
-   * - router: the router object ([[UIRouter]])
+   * - router: the router object ([[Router]])
    *
    * #### Example:
    * ```js
@@ -89,7 +89,7 @@ export declare class UrlRuleFactory {
    */
   fromState(
     stateOrDecl: StateObject | StateDeclaration,
-    router: UIRouter,
+    router: Router,
   ): StateRule;
   /**
    * A UrlRule which matches based on a regular expression
@@ -102,7 +102,7 @@ export declare class UrlRuleFactory {
    *
    * - regexp match array (from `regexp`)
    * - url: the current Url ([[UrlParts]])
-   * - router: the router object ([[UIRouter]])
+   * - router: the router object ([[Router]])
    *
    * #### Example:
    * ```js

package/types/router/core/url/urlRules.d.ts

@@ -1,4 +1,4 @@
-import { UIRouter } from "../router";
+import { Router } from "../router";
 import { UrlRule, UrlRuleHandlerFn } from "./interface";
 import { TargetState, TargetStateDef } from "../state";
 import { UrlMatcher } from "./urlMatcher";
@@ -11,7 +11,7 @@ import { UrlRuleFactory } from "./urlRule";
  *
  * The most commonly used methods are [[otherwise]] and [[when]].
  *
- * This API is found at `router.urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
+ * This API is found at `router.urlService.rules` (see: [[Router.urlService]], [[URLService.rules]])
  */
 export declare class UrlRules {
   private router;
@@ -23,9 +23,9 @@ export declare class UrlRules {
   /** @internal */ private _rules;
   /** @internal */ private _id;
   /** @internal */
-  constructor(/** @internal */ router: UIRouter);
+  constructor(/** @internal */ router: Router);
   /** @internal */
-  dispose(router?: UIRouter): void;
+  dispose(router?: Router): void;
   /**
    * Defines the initial state, path, or behavior to use when the app starts.
    *
@@ -86,7 +86,7 @@ export declare class UrlRules {
    * .otherwise({ state: 'home', params: { dashboard: 'default' } });
    * ```
    *
-   * - If `handler` is a function, the function receives the current url ([[UrlParts]]) and the [[UIRouter]] object.
+   * - If `handler` is a function, the function receives the current url ([[UrlParts]]) and the [[Router]] object.
    *   The function can perform actions, and/or return a value.
    *
    * #### Example:
@@ -220,7 +220,7 @@ export declare class UrlRules {
    *
    * ---
    *
-   * When the handler is a function, it receives the matched value, the current URL, and the `UIRouter` object (See [[UrlRuleHandlerFn]]).
+   * When the handler is a function, it receives the matched value, the current URL, and the `Router` object (See [[UrlRuleHandlerFn]]).
    * The "matched value" differs based on the `matcher`.
    * For [[UrlMatcher]]s, it will be the matched state params.
    * For `RegExp`, it will be the match array from `regexp.exec()`.

package/types/router/core/url/urlService.d.ts

@@ -1,4 +1,4 @@
-import { UIRouter } from "../router";
+import { Router } from "../router";
 import { LocationServices } from "../common";
 import { MatchResult, UrlParts, UrlSyncApi } from "./interface";
 import { UrlRules } from "./urlRules";
@@ -23,7 +23,7 @@ export declare class UrlService implements LocationServices, UrlSyncApi {
    */
   config: UrlConfig;
   /** @internal */
-  constructor(/** @internal */ router: UIRouter);
+  constructor(/** @internal */ router: Router);
 
   /**
    * Gets the current URL parts
@@ -56,9 +56,9 @@ export declare class UrlService implements LocationServices, UrlSyncApi {
    * Starts or stops listening for URL changes
    *
    * Call this sometime after calling [[deferIntercept]] to start monitoring the url.
-   * This causes UI-Router to start listening for changes to the URL, if it wasn't already listening.
+   * This causes Router to start listening for changes to the URL, if it wasn't already listening.
    *
-   * If called with `false`, UI-Router will stop listening (call listen(true) to start listening again).
+   * If called with `false`, Router will stop listening (call listen(true) to start listening again).
    *
    * #### Example:
    * ```js
@@ -78,15 +78,15 @@ export declare class UrlService implements LocationServices, UrlSyncApi {
   /**
    * Disables monitoring of the URL.
    *
-   * Call this method before UI-Router has bootstrapped.
-   * It will stop UI-Router from performing the initial url sync.
+   * Call this method before Router has bootstrapped.
+   * It will stop Router from performing the initial url sync.
    *
    * This can be useful to perform some asynchronous initialization before the router starts.
-   * Once the initialization is complete, call [[listen]] to tell UI-Router to start watching and synchronizing the URL.
+   * Once the initialization is complete, call [[listen]] to tell Router to start watching and synchronizing the URL.
    *
    * #### Example:
    * ```js
-   * // Prevent UI-Router from automatically intercepting URL changes when it starts;
+   * // Prevent Router from automatically intercepting URL changes when it starts;
    * urlService.deferIntercept();
    *
    * fetch('/states.json').then(resp => resp.json()).then(data => {

package/types/router/core/view/interface.d.ts

@@ -5,7 +5,7 @@ export interface ViewContext {
   name: string;
   parent: ViewContext;
 }
-export interface ActiveUIView {
+export interface ActiveNGView {
   /** type of framework, e.g., "ng1" or "ng2" */
   $type: string;
   /** An auto-incremented id */

package/types/router/core/view/view.d.ts

@@ -1,8 +1,8 @@
 import { TypedMap } from "../common/common";
 import { PathNode } from "../path/pathNode";
-import { ActiveUIView, ViewContext, ViewConfig } from "./interface";
+import { ActiveNGView, ViewContext, ViewConfig } from "./interface";
 import { _ViewDeclaration } from "../state/interface";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 export declare type ViewConfigFactory = (
   path: PathNode[],
   decl: _ViewDeclaration,
@@ -11,13 +11,13 @@ export interface ViewServicePluginAPI {
   _rootViewContext(context?: ViewContext): ViewContext;
   _viewConfigFactory(viewType: string, factory: ViewConfigFactory): any;
   /** @param id router.$id + "." + ngView.id */
-  _registeredUIView(id: string): ActiveUIView;
-  _registeredUIViews(): ActiveUIView[];
+  _registeredNGView(id: string): ActiveNGView;
+  _registeredNGViews(): ActiveNGView[];
   _activeViewConfigs(): ViewConfig[];
   _onSync(listener: ViewSyncListener): Function;
 }
 export interface ViewTuple {
-  ngView: ActiveUIView;
+  ngView: ActiveNGView;
   viewConfig: ViewConfig;
 }
 export interface ViewSyncListener {
@@ -33,9 +33,9 @@ export interface ViewSyncListener {
  *   The views from exited states are deactivated via [[deactivateViewConfig]].
  *   (See: the [[registerActivateViews]] Transition Hook)
  *
- * - As `ui-view` components pop in and out of existence, they register themselves using [[registerUIView]].
+ * - As `ui-view` components pop in and out of existence, they register themselves using [[registerNGView]].
  *
- * - When the [[sync]] function is called, the registered `ui-view`(s) ([[ActiveUIView]])
+ * - When the [[sync]] function is called, the registered `ui-view`(s) ([[ActiveNGView]])
  * are configured with the matching [[ViewConfig]](s)
  *
  */
@@ -106,8 +106,8 @@ export declare class ViewService {
    * @internal
    */
   static matches: (
-    ngViewsByFqn: TypedMap<ActiveUIView>,
-    ngView: ActiveUIView,
+    ngViewsByFqn: TypedMap<ActiveNGView>,
+    ngView: ActiveNGView,
   ) => (viewConfig: ViewConfig) => boolean;
   /**
    * Normalizes a view's name from a state.views configuration block.
@@ -120,7 +120,7 @@ export declare class ViewService {
    *
    * @returns the normalized ngViewName and ngViewContextAnchor that the view targets
    */
-  static normalizeUIViewTarget(
+  static normalizeNGViewTarget(
     context: ViewContext,
     rawViewName?: string,
   ): {
@@ -128,7 +128,7 @@ export declare class ViewService {
     ngViewContextAnchor: string;
   };
   /** @internal */
-  constructor(/** @internal */ router: UIRouter);
+  constructor(/** @internal */ router: Router);
   /** @internal */
   private _rootViewContext;
   /** @internal */
@@ -154,13 +154,13 @@ export declare class ViewService {
    * Note: the `ui-view` component uses the `ViewConfig` to determine what view should be loaded inside the `ui-view`,
    * and what the view's state context is.
    *
-   * Note: There is no corresponding `deregisterUIView`.
-   *       A `ui-view` should hang on to the return value of `registerUIView` and invoke it to deregister itself.
+   * Note: There is no corresponding `deregisterNGView`.
+   *       A `ui-view` should hang on to the return value of `registerNGView` and invoke it to deregister itself.
    *
-   * @param ngView The metadata for a UIView
+   * @param ngView The metadata for a NGView
    * @return a de-registration function used when the view is destroyed.
    */
-  registerUIView(ngView: ActiveUIView): () => void;
+  registerNGView(ngView: ActiveNGView): () => void;
   /**
    * Returns the list of views currently available on the page, by fully-qualified name.
    *

package/types/router/directives/viewDirective.d.ts

@@ -1,15 +1,15 @@
 /** @publicapi @module directives */ /** */
 import { IDirective } from "../..";
-import { ActiveUIView } from "../core";
+import { ActiveNGView } from "../core";
 import { Ng1ViewConfig } from "../statebuilders/views";
 
 /** @hidden */
-export declare type UIViewData = {
+export declare type NGViewData = {
   $cfg: Ng1ViewConfig;
-  $ngView: ActiveUIView;
+  $ngView: ActiveNGView;
 };
 /** @hidden */
-export declare type UIViewAnimData = {
+export declare type NGViewAnimData = {
   $animEnter: Promise<any>;
   $animLeave: Promise<any>;
   $$animLeave: {

package/types/router/interface.d.ts

@@ -372,14 +372,14 @@ export interface Ng1ViewDeclaration extends _ViewDeclaration {
 /**
  * The shape of a controller for a view (and/or component), defining the controller callbacks.
  *
- * A view in UI-Router is comprised of either a `component` ([[Ng1ViewDeclaration.component]]) or a combination of a
+ * A view in Router is comprised of either a `component` ([[Ng1ViewDeclaration.component]]) or a combination of a
  * `template` (or `templateProvider`) and a `controller` (or `controllerProvider`).
  *
  * The `controller` object (or the `component`'s controller object) can define component-level controller callbacks,
- * which UI-Router will call at the appropriate times.  These callbacks are similar to Transition Hooks
+ * which Router will call at the appropriate times.  These callbacks are similar to Transition Hooks
  * ([[IHookRegistry]]), but are only called if the view is currently active.
  *
- * This interface defines the UI-Router component callbacks.
+ * This interface defines the Router component callbacks.
  *
  */
 export interface Ng1Controller {
@@ -468,7 +468,7 @@ export interface TemplateFactoryProvider {
   /**
    * Forces $templateFactory to use $http instead of $templateRequest.
    *
-   * UI-Router uses `$templateRequest` by default on angular 1.3+.
+   * Router uses `$templateRequest` by default on angular 1.3+.
    * Use this method to choose to use `$http` instead.
    *
    * ---

package/types/router/locationServices.d.ts

@@ -1,8 +1,8 @@
 /** @publicapi @module ng1 */ /** */
-import { LocationConfig, LocationServices, UIRouter } from "./core";
+import { LocationConfig, LocationServices, Router } from "./core";
 import { ILocationService, ILocationProvider, IWindowService } from "../index";
 /**
- * Implements UI-Router LocationServices and LocationConfig using Angular 1's $location service
+ * Implements Router LocationServices and LocationConfig using Angular 1's $location service
  * @internalapi
  */
 export declare class Ng1LocationServices
@@ -34,7 +34,7 @@ export declare class Ng1LocationServices
    *
    * @param router
    */
-  static monkeyPatchPathParameterType(router: UIRouter): void;
+  static monkeyPatchPathParameterType(router: Router): void;
   constructor($locationProvider: ILocationProvider);
   onChange(callback: Function): () => Function[];
   html5Mode(): any;

package/types/router/services.d.ts

@@ -2,7 +2,7 @@ import { IRootScopeService } from "../";
 import { ResolveContext, TypedMap } from "./core";
 import { StateProvider } from "./stateProvider";
 declare module "./core/lib/router" {
-  interface UIRouter {
+  interface Router {
     /** @hidden */
     stateProvider: StateProvider;
   }

package/types/router/stateProvider.d.ts

@@ -12,9 +12,9 @@ import { Ng1StateDeclaration } from "./interface";
  * 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
+ * A state corresponds to a "place" in the application in terms of the overall NG and
  * navigation. A state describes (via the controller / template / view properties) what
- * the UI looks like and does at that place.
+ * the NG 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

package/types/router/viewScroll.d.ts

@@ -1,4 +1,4 @@
-export interface UIViewScrollProvider {
+export interface NGViewScrollProvider {
   /**
    * Uses standard anchorScroll behavior
    *

package/src/router/url/url-matcher-factory.js

@@ -1,77 +0,0 @@
-import { forEach, isDefined, isFunction, isObject } from "../../shared/utils";
-import { UrlMatcher } from "./url-matcher";
-import { ParamFactory } from "../params/param-factory";
-
-/**
- * Factory for [[UrlMatcher]] instances.
- *
- * The factory is available to ng1 services as
- * `$urlMatcherFactory` or ng1 providers as `$urlMatcherFactoryProvider`.
- */
-export class UrlMatcherFactory {
-  // TODO: move implementations to UrlConfig (urlService.config)
-  constructor(urlServiceConfig) {
-    this.urlServiceConfig = urlServiceConfig;
-    /** Creates a new [[Param]] for a given location (DefType) */
-    this.paramFactory = new ParamFactory(urlServiceConfig);
-    /** @deprecated use [[UrlConfig.caseInsensitive]] */
-    this.caseInsensitive = (value) => urlServiceConfig.caseInsensitive(value);
-    /** @deprecated use [[UrlConfig.defaultSquashPolicy]] */
-    this.defaultSquashPolicy = (value) =>
-      urlServiceConfig.defaultSquashPolicy(value);
-    /** @deprecated use [[UrlConfig.strictMode]] */
-    this.strictMode = (value) => urlServiceConfig.strictMode(value);
-    /** @deprecated use [[UrlConfig.type]] */
-    this.type = (name, definition, definitionFn) => {
-      return urlServiceConfig.type(name, definition, definitionFn) || this;
-    };
-  }
-  /**
-   * Creates a [[UrlMatcher]] for the specified pattern.
-   *
-   * @param pattern  The URL pattern.
-   * @param config  The config object hash.
-   * @returns The UrlMatcher.
-   */
-  compile(pattern, config) {
-    const urlConfig = this.urlServiceConfig;
-    // backward-compatible support for config.params -> config.state.params
-    const params = config && !config.state && config.params;
-    config = params ? Object.assign({ state: { params } }, config) : config;
-    const globalConfig = {
-      strict: urlConfig._isStrictMode,
-      caseInsensitive: urlConfig._isCaseInsensitive,
-      decodeParams: urlConfig._decodeParams,
-    };
-    return new UrlMatcher(
-      pattern,
-      urlConfig.paramTypes,
-      this.paramFactory,
-      Object.assign(globalConfig, config),
-    );
-  }
-  /**
-   * Returns true if the specified object is a [[UrlMatcher]], or false otherwise.
-   *
-   * @param object  The object to perform the type check against.
-   * @returns `true` if the object matches the `UrlMatcher` interface, by
-   *          implementing all the same methods.
-   */
-  isMatcher(object) {
-    // TODO: typeof?
-    if (!isObject(object)) return false;
-    let result = true;
-    forEach(UrlMatcher.prototype, (val, name) => {
-      if (isFunction(val))
-        result = result && isDefined(object[name]) && isFunction(object[name]);
-    });
-    return result;
-  }
-
-  $get() {
-    const urlConfig = this.urlServiceConfig;
-    urlConfig.paramTypes.enqueue = false;
-    urlConfig.paramTypes._flushTypeQueue();
-    return this;
-  }
-}

package/src/router/url/url-router.js

@@ -1,101 +0,0 @@
-import { EventBus } from "../../core/pubsub";
-import { stripLastPathElement } from "../../shared/strings";
-
-function appendBasePath(url, isHtml5, absolute, baseHref) {
-  if (baseHref === "/") return url;
-  if (isHtml5) return stripLastPathElement(baseHref) + url;
-  if (absolute) return baseHref.slice(1) + url;
-  return url;
-}
-/**
- * Updates URL and responds to URL changes
- *
- * ### Deprecation warning:
- * This class is now considered to be an internal API
- * Use the [[UrlService]] instead.
- * For configuring URL rules, use the [[UrlRules]] which can be found as [[UrlService.rules]].
- */
-export class UrlRouter {
-  /**
-   * @param {angular.UrlService} urlService
-   */
-  constructor(urlService, urlRuleFactory, $locationProvider) {
-    this.urlService = urlService;
-    this.urlRuleFactory = urlRuleFactory;
-    this.$locationProvider = $locationProvider;
-    EventBus.subscribe("$urlRouter:update", () => {
-      this.update();
-    });
-  }
-
-  update(read) {
-    const $url = this.urlService;
-    if (read) {
-      this.location = $url.url();
-      return;
-    }
-    if ($url.url() === this.location) return;
-    $url.url(this.location, true);
-  }
-  /**
-   * Pushes a new location to the browser history.
-   *
-   * @internal
-   * @param urlMatcher
-   * @param params
-   * @param options
-   */
-  push(urlMatcher, params, options) {
-    const replace = options && !!options.replace;
-    this.urlService.url(urlMatcher.format(params || {}), replace);
-  }
-  /**
-   * Builds and returns a URL with interpolated parameters
-   *
-   * #### Example:
-   * ```js
-   * matcher = $umf.compile("/about/:person");
-   * params = { person: "bob" };
-   * $bob = $urlRouter.href(matcher, params);
-   * // $bob == "/about/bob";
-   * ```
-   *
-   * @param urlMatcher The [[UrlMatcher]] object which is used as the template of the URL to generate.
-   * @param params An object of parameter values to fill the matcher's required parameters.
-   * @param options Options object. The options are:
-   *
-   * - **`absolute`** - {boolean=false},  If true will generate an absolute url, e.g. "http://www.example.com/fullurl".
-   *
-   * @returns Returns the fully compiled URL, or `null` if `params` fail validation against `urlMatcher`
-   */
-  href(urlMatcher, params, options) {
-    let url = urlMatcher.format(params);
-    if (url == null) return null;
-    options = options || { absolute: false };
-    const cfg = this.urlService.config;
-    const isHtml5 = this.urlService.html5Mode();
-    if (!isHtml5 && url !== null) {
-      url = "#" + this.$locationProvider.hashPrefix() + url;
-    }
-    url = appendBasePath(
-      url,
-      isHtml5,
-      options.absolute,
-      this.urlService.baseHref(),
-    );
-    if (!options.absolute || !url) {
-      return url;
-    }
-    const slash = !isHtml5 && url ? "/" : "";
-    const cfgPort = this.urlService.$location.port();
-    const port = cfgPort === 80 || cfgPort === 443 ? "" : ":" + cfgPort;
-    return [
-      cfg.protocol(),
-      "://",
-      this.urlService.$location.host(),
-      port,
-      slash,
-      url,
-    ].join("");
-  }
-}