@angular-wave/angular.ts 0.0.28 → 0.0.30

package/test/router/view-hook.spec.js

@@ -25,7 +25,7 @@ describe("view hooks", () => {
     window.angular = new Angular();
     publishExternalAPI();
     app = window.angular
-      .module("defaultModule", ["ui.router"])
+      .module("defaultModule", ["ng.router"])
       .config(($stateProvider) => {
         $stateProvider.state({ name: "foo", url: "/foo", component: "foo" });
         $stateProvider.state({ name: "bar", url: "/bar", component: "bar" });
@@ -47,7 +47,7 @@ describe("view hooks", () => {
       $state = _$state_;
       $q = _$q_;
       $timeout = _$timeout_;
-      $compile("<div><ui-view></ui-view></div>")($rootScope.$new());
+      $compile("<div><ng-view></ng-view></div>")($rootScope.$new());
     });
   });
 

package/test/router/view-scroll.spec.js

@@ -3,30 +3,30 @@ import { Angular } from "../../src/loader";
 import { publishExternalAPI } from "../../src/public";
 import { wait } from "../test-utils";
 
-describe("uiView", () => {
+describe("ngView", () => {
   describe("scrollIntoView", () => {
-    let elem, $anchorScroll, $uiViewScroll, $timeout;
+    let elem, $anchorScroll, $ngViewScroll, $timeout;
 
     beforeEach(() => {
       dealoc(document.getElementById("dummy"));
       window.angular = new Angular();
       publishExternalAPI();
-      window.angular.module("defaultModule", ["ui.router"]);
+      window.angular.module("defaultModule", ["ng.router"]);
       let $injector = window.angular.bootstrap(
         document.getElementById("dummy"),
         ["defaultModule"],
       );
 
-      $injector.invoke((_$uiViewScroll_, _$timeout_, _$anchorScroll_) => {
+      $injector.invoke((_$ngViewScroll_, _$timeout_, _$anchorScroll_) => {
         $anchorScroll = _$anchorScroll_;
-        $uiViewScroll = _$uiViewScroll_;
+        $ngViewScroll = _$ngViewScroll_;
         $timeout = _$timeout_;
       });
       elem = [{ scrollIntoView: jasmine.createSpy("scrollIntoView") }];
     });
 
     it("should scroll element into view after timeout", async () => {
-      $uiViewScroll(elem);
+      $ngViewScroll(elem);
       expect(elem[0].scrollIntoView).not.toHaveBeenCalled();
 
       await wait(100);
@@ -34,7 +34,7 @@ describe("uiView", () => {
     });
 
     it("should return the promise from the timeout", async () => {
-      const promise = $uiViewScroll(elem);
+      const promise = $ngViewScroll(elem);
 
       await wait(100);
       expect(elem[0].scrollIntoView).toHaveBeenCalled();
@@ -43,18 +43,18 @@ describe("uiView", () => {
   });
 
   describe("useAnchorScroll", () => {
-    let elem, $anchorScroll, $uiViewScroll;
+    let elem, $anchorScroll, $ngViewScroll;
 
     beforeEach(() => {
       dealoc(document.getElementById("dummy"));
       window.angular = new Angular();
       publishExternalAPI();
-      let module = window.angular.module("defaultModule", ["ui.router"]);
-      module.config(($provide, $uiViewScrollProvider) => {
+      let module = window.angular.module("defaultModule", ["ng.router"]);
+      module.config(($provide, $ngViewScrollProvider) => {
         $provide.decorator("$anchorScroll", function ($delegate) {
           return jasmine.createSpy("$anchorScroll");
         });
-        $uiViewScrollProvider.useAnchorScroll();
+        $ngViewScrollProvider.useAnchorScroll();
       });
 
       let $injector = window.angular.bootstrap(
@@ -62,15 +62,15 @@ describe("uiView", () => {
         ["defaultModule"],
       );
 
-      $injector.invoke((_$uiViewScroll_, _$anchorScroll_) => {
+      $injector.invoke((_$ngViewScroll_, _$anchorScroll_) => {
         $anchorScroll = _$anchorScroll_;
-        $uiViewScroll = _$uiViewScroll_;
+        $ngViewScroll = _$ngViewScroll_;
       });
       elem = [{ scrollIntoView: jasmine.createSpy("scrollIntoView") }];
     });
 
     it("should call $anchorScroll", () => {
-      $uiViewScroll();
+      $ngViewScroll();
       expect($anchorScroll).toHaveBeenCalled();
     });
   });

package/test/router/view.spec.js

@@ -32,7 +32,7 @@ describe("view", () => {
     publishExternalAPI();
 
     window.angular
-      .module("defaultModule", ["ui.router"])
+      .module("defaultModule", ["ng.router"])
       .config(
         function (
           _$provide_,
@@ -106,7 +106,7 @@ describe("view", () => {
 
     it("uses the controllerProvider to get controller dynamically", async () => {
       $controllerProvider.register("AcmeFooController", () => {});
-      elem.append($compile("<div><ui-view></ui-view></div>")(scope));
+      elem.append($compile("<div><ng-view></ng-view></div>")(scope));
 
       const view = tail(path).views[0];
       view.load();

package/types/router/core/common/coreservices.d.ts

@@ -39,7 +39,7 @@ export interface CoreServices {
  * Implementors should pass these through to the underlying URL mechanism.
  * The underlying URL mechanism might be browser APIs, framework APIs, or some 3rd party URL management library.
  *
- * UI-Router Core includes three basic implementations:
+ * Router Core includes three basic implementations:
  *
  * - [[PushStateLocationService]]
  * - [[HashLocationService]]
@@ -61,7 +61,7 @@ export interface LocationServices {
  * Implementors should pass these through to the underlying URL APIs.
  * The underlying URL mechanism might be browser APIs, framework APIs, or some 3rd party URL management library.
  *
- * UI-Router Core includes two basic implementations:
+ * Router Core includes two basic implementations:
  *
  * - [[BrowserLocationConfig]]
  * - [[MemoryLocationConfig]]

package/types/router/core/common/trace.d.ts

@@ -1,6 +1,6 @@
 import { Transition } from "../transition/transition";
 import { ViewTuple } from "../view";
-import { ActiveUIView, ViewConfig, ViewContext } from "../view/interface";
+import { ActiveNGView, ViewConfig, ViewContext } from "../view/interface";
 import { Resolvable } from "../resolve/resolvable";
 import { PathNode } from "../path/pathNode";
 import { PolicyWhen } from "../resolve/interface";
@@ -24,12 +24,12 @@ declare enum Category {
   RESOLVE = 0,
   TRANSITION = 1,
   HOOK = 2,
-  UIVIEW = 3,
+  NGVIEW = 3,
   VIEWCONFIG = 4,
 }
 export { Category };
 /**
- * Prints UI-Router Transition trace information to the console.
+ * Prints Router Transition trace information to the console.
  */
 export declare class Trace {
   /** @internal */
@@ -101,17 +101,17 @@ export declare class Trace {
   /** @internal called by ui-router code */
   traceSuccess(finalState: StateObject, trans: Transition): void;
   /** @internal called by ui-router code */
-  traceUIViewEvent(event: string, viewData: ActiveUIView, extra?: string): void;
+  traceNGViewEvent(event: string, viewData: ActiveNGView, extra?: string): void;
   /** @internal called by ui-router code */
-  traceUIViewConfigUpdated(viewData: ActiveUIView, context: ViewContext): void;
+  traceNGViewConfigUpdated(viewData: ActiveNGView, context: ViewContext): void;
   /** @internal called by ui-router code */
-  traceUIViewFill(viewData: ActiveUIView, html: string): void;
+  traceNGViewFill(viewData: ActiveNGView, html: string): void;
   /** @internal called by ui-router code */
   traceViewSync(pairs: ViewTuple[]): void;
   /** @internal called by ui-router code */
   traceViewServiceEvent(event: string, viewConfig: ViewConfig): void;
   /** @internal called by ui-router code */
-  traceViewServiceUIViewEvent(event: string, viewData: ActiveUIView): void;
+  traceViewServiceNGViewEvent(event: string, viewData: ActiveNGView): void;
 }
 /**
  * The [[Trace]] singleton

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

@@ -3,12 +3,13 @@ import { StateDeclaration } from "./state/interface";
 import { StateObject } from "./state/stateObject";
 import { Transition } from "./transition/transition";
 import { Queue } from "./common/queue";
+/**
  * Global router state
  *
  * This is where we hold the global mutable state such as current state, current
  * params, current transition, etc.
  */
-export declare class UIRouterGlobals {
+export declare class RouterGlobals {
   /**
    * Current parameter values
    *

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

@@ -1,9 +1,9 @@
-import { UIRouter } from "./router";
+import { Router } from "./router";
 /**
  * An interface for getting values from dependency injection.
  *
  * This is primarily used to get resolve values for a given token.
- * An instance of the `UIInjector` can be retrieved from the current transition using [[Transition.injector]].
+ * An instance of the `NGInjector` can be retrieved from the current transition using [[Transition.injector]].
  *
  * ---
  *
@@ -13,7 +13,7 @@ import { UIRouter } from "./router";
  * In Angular 2, the native injector might be the root Injector,
  * or it might be a lazy loaded `NgModule` injector scoped to a lazy load state tree.
  */
-export interface UIInjector {
+export interface NGInjector {
   /**
    * Gets a value from the injector.
    *
@@ -89,10 +89,3 @@ export interface UIInjector {
   getNative(token: any): any;
   getNative<T>(token: any): T;
 }
-export interface UIRouterPlugin {
-  name: string;
-}
-export declare abstract class UIRouterPluginBase implements UIRouterPlugin {
-  abstract name: string;
-  dispose(router: UIRouter): void;
-}

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

@@ -53,7 +53,7 @@ export interface ParamDeclaration {
    * Specifies the default value for this parameter.
    * This implicitly sets this parameter as optional.
    *
-   * When UI-Router routes to a state and no value is specified for this parameter in the URL or transition,
+   * When Router routes to a state and no value is specified for this parameter in the URL or transition,
    * the default value will be used instead.
    * If value is a function, it will be injected and invoked, and the return value used.
    *
@@ -245,7 +245,7 @@ export interface ParamDeclaration {
    * Normally, if a parameter value changes, the state which declared that the parameter will be reloaded (entered/exited).
    * When a parameter is `dynamic`, a transition still occurs, but it does not cause the state to exit/enter.
    *
-   * This can be useful to build UI where the component updates itself when the param values change.
+   * This can be useful to build NG where the component updates itself when the param values change.
    * A common scenario where this is useful is searching/paging/sorting.
    *
    * ---
@@ -373,7 +373,7 @@ export interface Replace {
  * - some internal string representation
  *
  * Typed parameter definitions control how parameter values are encoded (to the URL) and decoded (from the URL).
- * UI-Router always provides the decoded parameter values to the user (from methods such as [[Transition.params]])).
+ * Router always provides the decoded parameter values to the user (from methods such as [[Transition.params]])).
  *
  * For example, if a state has a url of `/foo/{fooId:int}` (the `fooId` parameter is of the `int` ParamType)
  * and if the browser is at `/foo/123`, then the 123 is parsed as an integer:

package/types/router/core/resolve/resolveContext.d.ts

@@ -3,12 +3,12 @@ import { PathNode } from "../path/pathNode";
 import { Resolvable } from "./resolvable";
 import { StateObject } from "../state/stateObject";
 import { Transition } from "../transition/transition";
-import { UIInjector } from "../interface";
+import { NGInjector } from "../interface";
 export declare const NATIVE_INJECTOR_TOKEN: string;
 /**
  * Encapsulates Dependency Injection for a path of nodes
  *
- * UI-Router states are organized as a tree.
+ * Router states are organized as a tree.
  * A nested state has a path of ancestors to the root of the tree.
  * When a state is being activated, each element in the path is wrapped as a [[PathNode]].
  * A `PathNode` is a stateful object that holds things like parameters and resolvables for the state being activated.
@@ -17,7 +17,7 @@ export declare const NATIVE_INJECTOR_TOKEN: string;
  */
 export declare class ResolveContext {
   private _path;
-  _injector: UIInjector;
+  _injector: NGInjector;
   constructor(_path: PathNode[]);
   /** Gets all the tokens found in the resolve context, de-duplicated */
   getTokens(): any[];
@@ -86,7 +86,7 @@ export declare class ResolveContext {
       value: any;
     }[]
   >;
-  injector(): UIInjector;
+  injector(): NGInjector;
   findNode(resolvable: Resolvable): PathNode;
   /**
    * Gets the async dependencies of a Resolvable

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

@@ -4,17 +4,16 @@ import { TransitionService } from "./transition/transitionService";
 import { ViewService } from "./view/view";
 import { StateRegistry } from "./state/stateRegistry";
 import { StateService } from "./state/stateService";
-import { UIRouterGlobals } from "./globals";
-import { UIRouterPlugin } from "./interface";
+import { RouterGlobals } from "./globals";
 import { UrlService } from "./url/urlService";
 import { LocationServices, LocationConfig } from "./common/coreservices";
 import { Trace } from "./common/trace";
 /**
- * An instance of UI-Router.
+ * An instance of Router.
  *
  * This object contains references to service APIs which define your application's routing behavior.
  */
-export declare class UIRouter {
+export declare class Router {
   locationService: LocationServices;
   locationConfig: LocationConfig;
   /** @internal */ $id: number;
@@ -25,7 +24,7 @@ export declare class UIRouter {
   /** Provides services related to ui-view synchronization */
   viewService: ViewService;
   /** An object that contains global router state, such as the current state and params */
-  globals: UIRouterGlobals;
+  globals: RouterGlobals;
   /** A service that exposes global Transition Hooks */
   transitionService: TransitionService;
   /**
@@ -44,23 +43,8 @@ export declare class UIRouter {
   stateRegistry: StateRegistry;
   /** Provides services related to states */
   stateService: StateService;
-  /** @internal plugin instances are registered here */
-  private _plugins;
-
   /**
-   * Disposes this router instance
-   *
-   * When called, clears resources retained by the router by calling `dispose(this)` on all
-   * registered [[disposable]] objects.
-   *
-   * Or, if a `disposable` object is provided, calls `dispose(this)` on that object only.
-   *
-   * @internal
-   * @param disposable (optional) the disposable to dispose
-   */
-  dispose(disposable?: any): void;
-  /**
-   * Creates a new `UIRouter` object
+   * Creates a new `Router` object
    *
    * @param locationService a [[LocationServices]] implementation
    * @param locationConfig a [[LocationConfig]] implementation
@@ -70,34 +54,4 @@ export declare class UIRouter {
     locationService?: LocationServices,
     locationConfig?: LocationConfig,
   );
-  /** Add plugin (as ES6 class) */
-  plugin<T extends UIRouterPlugin>(
-    plugin: {
-      new (router: UIRouter, options?: any): T;
-    },
-    options?: any,
-  ): T;
-  /** Add plugin (as javascript constructor function) */
-  plugin<T extends UIRouterPlugin>(
-    plugin: {
-      (router: UIRouter, options?: any): void;
-    },
-    options?: any,
-  ): T;
-  /** Add plugin (as javascript factory function) */
-  plugin<T extends UIRouterPlugin>(plugin: PluginFactory<T>, options?: any): T;
-  /**
-   * Returns a plugin registered with the given `pluginName`.
-   *
-   * @param pluginName the name of the plugin to get
-   * @return the plugin, or undefined
-   */
-  getPlugin(pluginName: string): UIRouterPlugin;
-  /**
-   * Returns all registered plugins
-   * @return all registered plugins
-   */
-  getPlugin(): UIRouterPlugin[];
 }
-/** @internal */
-export declare type PluginFactory<T> = (router: UIRouter, options?: any) => T;

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

@@ -31,7 +31,7 @@ export declare type ResolveTypes =
  * Base interface for declaring a view
  *
  * This interface defines the basic data that a normalized view declaration will have on it.
- * Each implementation of UI-Router (for a specific framework) should define its own extension of this interface.
+ * Each implementation of Router (for a specific framework) should define its own extension of this interface.
  * Add any additional fields that the framework requires to that interface.
  */
 export interface _ViewDeclaration {
@@ -42,20 +42,20 @@ export interface _ViewDeclaration {
   /**
    * The normalized address for the `ui-view` which this ViewConfig targets.
    *
-   * A ViewConfig targets a `ui-view` in the DOM (relative to the `uiViewContextAnchor`) which has
+   * A ViewConfig targets a `ui-view` in the DOM (relative to the `ngViewContextAnchor`) which has
    * a specific name.
    * @example `header` or `$default`
    *
-   * The `uiViewName` can also target a _nested view_ by providing a dot-notation address
+   * The `ngViewName` can also target a _nested view_ by providing a dot-notation address
    * @example `foo.bar` or `foo.$default.bar`
    */
-  $uiViewName?: string;
+  $ngViewName?: string;
   /**
-   * The normalized context anchor (state name) for the `uiViewName`
+   * The normalized context anchor (state name) for the `ngViewName`
    *
-   * When targeting a `ui-view`, the `uiViewName` address is anchored to a context name (state name).
+   * When targeting a `ui-view`, the `ngViewName` address is anchored to a context name (state name).
    */
-  $uiViewContextAnchor?: string;
+  $ngViewContextAnchor?: string;
   /**
    * A type identifier for the View
    *
@@ -86,7 +86,7 @@ export declare type RedirectToResult =
 /**
  * The StateDeclaration object is used to define a state or nested state.
  *
- * Note: Each implementation of UI-Router (for a specific framework)
+ * Note: Each implementation of Router (for a specific framework)
  * extends this interface as necessary.
  *
  * #### Example:
@@ -203,7 +203,7 @@ export interface StateDeclaration {
    * - Each key (string) is the name of the dependency.
    * - Each value (function) is an injectable function which returns the dependency, or a promise for the dependency.
    *
-   * This style is based on AngularJS injectable functions, but can be used with any UI-Router implementation.
+   * This style is based on AngularJS injectable functions, but can be used with any Router implementation.
    * If your code will be minified, the function should be ["annotated" in the AngularJS manner](https://docs.angularjs.org/guide/di#dependency-annotation).
    *
    * #### AngularJS Example:
@@ -257,7 +257,7 @@ export interface StateDeclaration {
    *
    * #### Special injectable tokens
    *
-   * - `UIRouter`: The [[UIRouter]] instance which has references to all the UI-Router services.
+   * - `Router`: The [[Router]] instance which has references to all the Router services.
    * - `Transition`: The current [[Transition]] object; information and API about the current transition, such as
    *    "to" and "from" State Parameters and transition options.
    * - `'$transition$'`: A string alias for the `Transition` injectable
@@ -428,7 +428,7 @@ export interface StateDeclaration {
    *
    * Note: `redirectTo` is processed as an `onStart` hook, before `LAZY` resolves.
    * If your redirect function relies on resolve data, get the [[Transition.injector]] and get a
-   * promise for the resolve data using [[UIInjector.getAsync]].
+   * promise for the resolve data using [[NGInjector.getAsync]].
    *
    * #### Example:
    * ```js
@@ -595,7 +595,7 @@ export interface StateDeclaration {
    *   It matches any state name that starts with the `name` (including child states that are not yet loaded).
    * - A `url` prefix.
    *   A future state's `url` property acts as a wildcard.
-   *   UI-Router matches all paths that begin with the `url`.
+   *   Router matches all paths that begin with the `url`.
    *   It effectively appends `.*` to the internal regular expression.
    *   When the prefix matches, the future state will begin loading.
    * - A `lazyLoad` function.

package/types/router/core/state/stateObject.d.ts

@@ -12,7 +12,7 @@ import { TargetState } from "./targetState";
 import { Transition } from "../transition/transition";
 import { Glob } from "../common/glob";
 /**
- * Internal representation of a UI-Router state.
+ * Internal representation of a Router state.
  *
  * Instances of this class are created when a [[StateDeclaration]] is registered with the [[StateRegistry]].
  *

package/types/router/core/state/stateQueueManager.d.ts

@@ -2,7 +2,7 @@ import { _StateDeclaration } from "./interface";
 import { StateObject } from "./stateObject";
 import { StateBuilder } from "./stateBuilder";
 import { StateRegistryListener } from "./stateRegistry";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 export declare class StateQueueManager {
   private router;
   states: {
@@ -12,7 +12,7 @@ export declare class StateQueueManager {
   listeners: StateRegistryListener[];
   queue: StateObject[];
   constructor(
-    router: UIRouter,
+    router: Router,
     states: {
       [key: string]: StateObject;
     },

package/types/router/core/state/stateRegistry.d.ts

@@ -4,7 +4,7 @@ import { StateQueueManager } from "./stateQueueManager";
 import { StateDeclaration, _StateDeclaration } from "./interface";
 import { BuilderFunction } from "./stateBuilder";
 import { StateOrName } from "./interface";
-import { UIRouter } from "../router";
+import { Router } from "../router";
 /**
  * The signature for the callback function provided to [[StateRegistry.onStatesChanged]].
  *
@@ -20,9 +20,10 @@ export declare type StateRegistryListener = (
 /**
  * A registry for all of the application's [[StateDeclaration]]s
  *
- * This API is found at `router.stateRegistry` ([[UIRouter.stateRegistry]])
+ * This API is found at `router.stateRegistry` ([[Router.stateRegistry]])
  */
 export declare class StateRegistry {
+  init($injector: any): void;
   private router;
   private _root;
   private states;
@@ -34,7 +35,7 @@ export declare class StateRegistry {
   /** @internal */
   listeners: StateRegistryListener[];
   /** @internal */
-  constructor(router: UIRouter);
+  constructor(router: Router);
   /** @internal */
   private _registerRoot;
   /**
@@ -72,7 +73,7 @@ export declare class StateRegistry {
    * Gets the implicit root state
    *
    * Gets the root of the state tree.
-   * The root state is implicitly created by UI-Router.
+   * The root state is implicitly created by Router.
    * Note: this returns the internal [[StateObject]] representation, not a [[StateDeclaration]]
    *
    * @return the root [[StateObject]]

package/types/router/core/state/stateService.d.ts

@@ -10,18 +10,18 @@ import {
 import { StateObject } from "./stateObject";
 import { TargetState } from "./targetState";
 import { RawParams } from "../params/interface";
-import { UIRouter } from "../router";
-import { UIInjector } from "../interface";
+import { Router } from "../router";
+import { NGInjector } from "../interface";
 import { StateParams } from "../params/stateParams";
 export declare type OnInvalidCallback = (
   toState?: TargetState,
   fromState?: TargetState,
-  injector?: UIInjector,
+  injector?: NGInjector,
 ) => HookResult;
 /**
  * Provides services related to ui-router states.
  *
- * This API is located at `router.stateService` ([[UIRouter.stateService]])
+ * This API is located at `router.stateService` ([[Router.stateService]])
  */
 export declare class StateService {
   private router;
@@ -30,29 +30,29 @@ export declare class StateService {
   /**
    * The [[Transition]] currently in progress (or null)
    *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.transition]]
+   * @deprecated This is a passthrough through to [[RouterGlobals.transition]]
    */
   transition: Transition;
   /**
    * The latest successful state parameters
    *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.params]]
+   * @deprecated This is a passthrough through to [[RouterGlobals.params]]
    */
   params: StateParams;
   /**
    * The current [[StateDeclaration]]
    *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.current]]
+   * @deprecated This is a passthrough through to [[RouterGlobals.current]]
    */
   current: StateDeclaration;
   /**
    * The current [[StateObject]] (an internal API)
    *
-   * @deprecated This is a passthrough through to [[UIRouterGlobals.$current]]
+   * @deprecated This is a passthrough through to [[RouterGlobals.$current]]
    */
   $current: StateObject;
   /** @internal */
-  constructor(/** @internal */ router: UIRouter);
+  constructor(/** @internal */ router: Router);
 
   /**
    * Handler for when [[transitionTo]] is called with an invalid state.
@@ -99,7 +99,7 @@ export declare class StateService {
    *
    * #### Example:
    * ```js
-   * let app angular.module('app', ['ui.router']);
+   * let app angular.module('app', ['ng.router']);
    *
    * app.controller('ctrl', function ($scope, $state) {
    *   $scope.reload = function(){
@@ -123,7 +123,7 @@ export declare class StateService {
    * ```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']);
+   * let app angular.module('app', ['ng.router']);
    *
    * app.controller('ctrl', function ($scope, $state) {
    *   $scope.reload = function(){
@@ -149,7 +149,7 @@ export declare class StateService {
    *
    * #### Example:
    * ```js
-   * let app = angular.module('app', ['ui.router']);
+   * let app = angular.module('app', ['ng.router']);
    *
    * app.controller('ctrl', function ($scope, $state) {
    *   $scope.changeState = function () {
@@ -202,7 +202,7 @@ export declare class StateService {
    *
    * #### Example:
    * ```js
-   * let app = angular.module('app', ['ui.router']);
+   * let app = angular.module('app', ['ng.router']);
    *
    * app.controller('ctrl', function ($scope, $state) {
    *   $scope.changeState = function () {

package/types/router/core/state/targetState.d.ts

@@ -25,7 +25,7 @@ import { RawParams } from "../params";
  * 3) and transition options
  * 4) the registered state object (the [[StateDeclaration]])
  *
- * Many UI-Router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
+ * Many 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.
  *

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

@@ -9,7 +9,7 @@ import { RegisteredHook } from "./hookRegistry";
  * The TransitionOptions object can be used to change the behavior of a transition.
  *
  * It is passed as the third argument to [[StateService.go]], [[StateService.transitionTo]].
- * It can also be used with a `uiSref`.
+ * It can also be used with a `ngSref`.
  */
 export interface TransitionOptions {
   /**
@@ -103,7 +103,7 @@ export interface TransitionHookOptions {
  *
  * Get a TreeChanges object using [[Transition.treeChanges]]
  *
- * A UI-Router Transition is from one Path in a State Tree to another Path.  For a given Transition,
+ * A Router Transition is from one Path in a State Tree to another Path.  For a given Transition,
  * this object stores the "to" and "from" paths, as well as subsets of those: the "retained",
  * "exiting" and "entering" paths.
  *