@angular-wave/angular.ts 0.0.28 → 0.0.30

package/src/router/state/state-service.js

@@ -53,8 +53,10 @@ export class StateService {
   }
 
   // Needs access to urlRouter, stateRegistry
-  constructor(router, globals, transitionService) {
-    this.router = router;
+  constructor(globals, transitionService) {
+    this.stateRegistry = undefined;
+    this.urlRouter = undefined;
+    this.urlService = undefined;
     this.globals = globals;
     this.transitionService = transitionService;
     this.invalidCallbacks = [];
@@ -96,10 +98,7 @@ export class StateService {
    * @internal
    */
   _handleInvalidTargetState(fromPath, toState) {
-    const fromState = PathUtils.makeTargetState(
-      this.router.stateRegistry,
-      fromPath,
-    );
+    const fromState = PathUtils.makeTargetState(this.stateRegistry, fromPath);
     const globals = this.globals;
     const latestThing = () => globals.transitionHistory.peekTail();
     const latest = latestThing();
@@ -278,7 +277,7 @@ export class StateService {
     // If we're reloading, find the state object to reload from
     if (isObject(options.reload) && !options.reload.name)
       throw new Error("Invalid reload state object");
-    const reg = this.router.stateRegistry;
+    const reg = this.stateRegistry;
     options.reloadState =
       options.reload === true
         ? reg.root()
@@ -287,18 +286,13 @@ export class StateService {
       throw new Error(
         `No such reload state '${isString(options.reload) ? options.reload : options.reload.name}'`,
       );
-    return new TargetState(
-      this.router.stateRegistry,
-      identifier,
-      params,
-      options,
-    );
+    return new TargetState(this.stateRegistry, identifier, params, options);
   }
 
   getCurrentPath() {
     const globals = this.globals;
     const latestSuccess = globals.successfulTransitions.peekTail();
-    const rootPath = () => [new PathNode(this.router.stateRegistry.root())];
+    const rootPath = () => [new PathNode(this.stateRegistry.root())];
     return latestSuccess ? latestSuccess.treeChanges().to : rootPath();
   }
   /**
@@ -350,7 +344,7 @@ export class StateService {
       if (error instanceof Rejection) {
         const isLatest = this.globals.lastStartedTransitionId <= trans.$id;
         if (error.type === RejectType.IGNORED) {
-          isLatest && this.router.urlRouter.update();
+          isLatest && EventBus.publish("urlRouter.update");
           // Consider ignored `Transition.run()` as a successful `transitionTo`
           return services.$q.when(this.globals.current);
         }
@@ -366,7 +360,7 @@ export class StateService {
           return redirect.run().catch(rejectedTransitionHandler(redirect));
         }
         if (error.type === RejectType.ABORTED) {
-          isLatest && this.router.urlRouter.update();
+          isLatest && EventBus.publish("urlRouter.update");
           return services.$q.reject(error);
         }
       }
@@ -415,7 +409,7 @@ export class StateService {
    */
   is(stateOrName, params, options) {
     options = defaults(options, { relative: this.$current });
-    const state = this.router.stateRegistry.matcher.find(
+    const state = this.stateRegistry.matcher.find(
       stateOrName,
       options.relative,
     );
@@ -474,7 +468,7 @@ export class StateService {
       if (!glob.matches(this.$current.name)) return false;
       stateOrName = this.$current.name;
     }
-    const state = this.router.stateRegistry.matcher.find(
+    const state = this.stateRegistry.matcher.find(
         stateOrName,
         options.relative,
       ),
@@ -514,7 +508,7 @@ export class StateService {
     };
     options = defaults(options, defaultHrefOpts);
     params = params || {};
-    const state = this.router.stateRegistry.matcher.find(
+    const state = this.stateRegistry.matcher.find(
       stateOrName,
       options.relative,
     );
@@ -525,7 +519,7 @@ export class StateService {
     if (!nav || nav.url === undefined || nav.url === null) {
       return null;
     }
-    return this.router.urlRouter.href(nav.url, params, {
+    return this.urlRouter.href(nav.url, params, {
       absolute: options.absolute,
     });
   }
@@ -557,7 +551,7 @@ export class StateService {
     return (this._defaultErrorHandler = handler || this._defaultErrorHandler);
   }
   get(stateOrName, base) {
-    const reg = this.router.stateRegistry;
+    const reg = this.stateRegistry;
     if (arguments.length === 0) return reg.get();
     return reg.get(stateOrName, base || this.$current);
   }
@@ -578,10 +572,7 @@ export class StateService {
     if (!state || !state.lazyLoad)
       throw new Error("Can not lazy load " + stateOrName);
     const currentPath = this.getCurrentPath();
-    const target = PathUtils.makeTargetState(
-      this.router.stateRegistry,
-      currentPath,
-    );
+    const target = PathUtils.makeTargetState(this.stateRegistry, currentPath);
     transition =
       transition || this.transitionService.create(currentPath, target);
     return lazyLoadState(transition, state);

package/src/router/state/target-state.js

@@ -22,7 +22,7 @@ import { stringify } from "../../shared/strings";
  * 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 ng-router APIs such as [[StateService.go]] take a [[StateOrName]] argument which can
  * either be a *state object* (a [[StateDeclaration]] or [[StateObject]]) or a *state name* (a string).
  * The `TargetState` class normalizes those options.
  *

package/src/router/state/views.js

@@ -11,7 +11,7 @@ export function getNg1ViewConfigFactory() {
   let templateFactory = null;
   return (path, view) => {
     templateFactory =
-      templateFactory || services.$injector.get("$templateFactory");
+      templateFactory || services.$injector.get("$templateFactory"); // TODO: remove static injector
     return [new Ng1ViewConfig(path, view, templateFactory)];
   };
 }
@@ -81,8 +81,8 @@ export function ng1ViewsBuilder(state) {
       config.$context,
       config.$name,
     );
-    config.$uiViewName = normalized.uiViewName;
-    config.$uiViewContextAnchor = normalized.uiViewContextAnchor;
+    config.$ngViewName = normalized.ngViewName;
+    config.$ngViewContextAnchor = normalized.ngViewContextAnchor;
     views[name] = config;
   });
   return views;
@@ -101,10 +101,10 @@ export class Ng1ViewConfig {
 
     /** @type {Number} */ this.$id = id++;
     this.loaded = false;
-    this.getTemplate = (uiView, context) =>
+    this.getTemplate = (ngView, context) =>
       this.component
         ? this.factory.makeComponentTemplate(
-            uiView,
+            ngView,
             context,
             this.component,
             this.viewDecl.bindings,

package/src/router/state-filters.js

@@ -1,5 +1,3 @@
-/** @publicapi @module ng1 */ /** */
-
 /**
  * `isState` Filter: truthy if the current state is the parameter
  *

package/src/router/state-provider.js

@@ -1,5 +1,3 @@
-/** @publicapi @module ng1 */ /** */
-
 import { val } from "../shared/hof";
 import { createProxyFunctions } from "../shared/common";
 import { minErr } from "../shared/utils";

package/src/router/template-factory.js

@@ -172,13 +172,13 @@ export class TemplateFactory {
    * 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} uiView {object} The parent ui-view (for binding outputs to callbacks)
+   * @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(uiView, context, component, bindings) {
+  makeComponentTemplate(ngView, context, component, bindings) {
     bindings = bindings || {};
     // Bind once prefix
     const prefix = "::"; //angular.version.minor >= 3 ? "::" : "";
@@ -194,8 +194,8 @@ export class TemplateFactory {
       // If the ui-view has an attribute which matches a binding on the routed component
       // then pass that attribute through to the routed component template.
       // Prefer ui-view wired mappings to resolve data, unless the resolve was explicitly bound using `bindings:`
-      if (uiView.attr(attrName) && !bindings[name])
-        return `${attrName}='${uiView.attr(attrName)}'`;
+      if (ngView.attr(attrName) && !bindings[name])
+        return `${attrName}='${ngView.attr(attrName)}'`;
       const resolveName = bindings[name] || name;
       // Pre-evaluate the expression for "@" bindings by enclosing in {{ }}
       // some-attr="{{ ::$resolve.someResolveName }}"

package/src/router/transition/transition-service.js

@@ -57,9 +57,9 @@ export let defaultTransOpts = {
  */
 export class TransitionService {
   /**
-   * @param {import('../router').UIRouter} router
+   * @param {import('../globals').UIRouterGlobals} globals
    */
-  constructor(router, globals, viewService) {
+  constructor(globals, viewService) {
     this._transitionCount = 0;
     /** The transition hook types, such as `onEnter`, `onStart`, etc */
     this._eventTypes = [];
@@ -67,7 +67,6 @@ export class TransitionService {
     this._registeredHooks = {};
     /** The  paths on a criteria object */
     this._criteriaPaths = {};
-    this.router = router;
     this.globals = globals;
     this.$view = viewService;
     this._deregisterHookFns = {};

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

@@ -18,8 +18,6 @@ export class UrlConfig {
     /** @type {ParamTypes} */
     this.paramTypes = new ParamTypes();
     /** @type {boolean} */
-    this._decodeParams = true;
-    /** @type {boolean} */
     this._isCaseInsensitive = false;
     /** @type {boolean} */
     this._isStrictMode = true;

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

@@ -41,7 +41,6 @@ export class UrlMatcherFactory {
     const globalConfig = {
       strict: urlConfig._isStrictMode,
       caseInsensitive: urlConfig._isCaseInsensitive,
-      decodeParams: urlConfig._decodeParams,
     };
     return new UrlMatcher(
       pattern,

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

@@ -39,7 +39,6 @@ const defaultConfig = {
   state: { params: {} },
   strict: true,
   caseInsensitive: true,
-  decodeParams: true,
 };
 /**
  * Matches URLs against patterns.
@@ -313,13 +312,6 @@ export class UrlMatcher {
   }
   _getDecodedParamValue(value, param) {
     if (isDefined(value)) {
-      if (this.config.decodeParams && !param.type.raw) {
-        if (Array.isArray(value)) {
-          value = value.map((paramValue) => decodeURIComponent(paramValue));
-        } else {
-          value = decodeURIComponent(value);
-        }
-      }
       value = param.type.decode(value);
     }
     return param.value(value);

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

@@ -1,3 +1,4 @@
+import { EventBus } from "../../core/pubsub";
 import { stripLastPathElement } from "../../shared/strings";
 
 function appendBasePath(url, isHtml5, absolute, baseHref) {
@@ -22,6 +23,9 @@ export class UrlRouter {
     this.urlService = urlService;
     this.urlRuleFactory = urlRuleFactory;
     this.$locationProvider = $locationProvider;
+    EventBus.subscribe("$urlRouter:update", () => {
+      this.update();
+    });
   }
 
   update(read) {

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

@@ -213,9 +213,9 @@ export class UrlService {
    * 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 ng-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`, ng-router will stop listening (call listen(true) to start listening again).
    *
    * #### Example:
    * ```js
@@ -243,15 +243,15 @@ export class UrlService {
   /**
    * 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 ng-router has bootstrapped.
+   * It will stop ng-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 ng-router to start watching and synchronizing the URL.
    *
    * #### Example:
    * ```js
-   * // Prevent UI-Router from automatically intercepting URL changes when it starts;
+   * // Prevent ng-router from automatically intercepting URL changes when it starts;
    * urlService.deferIntercept();
    *
    * fetch('/states.json').then(resp => resp.json()).then(data => {

package/src/router/view/view.js

@@ -8,6 +8,7 @@ import {
 import { curry, prop } from "../../shared/hof";
 import { isString } from "../../shared/utils";
 import { trace } from "../common/trace";
+import { getNg1ViewConfigFactory } from "../state/views";
 /**
  * The View service
  *
@@ -29,7 +30,7 @@ export class ViewService {
    * @param {number} $id
    */
   constructor($id) {
-    this._uiViews = [];
+    this._ngViews = [];
     this._viewConfigs = [];
     this._viewConfigFactories = {};
     this._listeners = [];
@@ -37,59 +38,60 @@ export class ViewService {
       _rootViewContext: this._rootViewContext.bind(this),
       _viewConfigFactory: this._viewConfigFactory.bind(this),
       _registeredUIView: (id) =>
-        find(this._uiViews, (view) => `${$id}.${view.id}` === id),
-      _registeredUIViews: () => this._uiViews,
+        find(this._ngViews, (view) => `${$id}.${view.id}` === id),
+      _registeredUIViews: () => this._ngViews,
       _activeViewConfigs: () => this._viewConfigs,
       _onSync: (listener) => {
         this._listeners.push(listener);
         return () => removeFrom(this._listeners, listener);
       },
     };
+    this._pluginapi._viewConfigFactory("ng1", getNg1ViewConfigFactory());
   }
 
   /**
    * Normalizes a view's name from a state.views configuration block.
    *
    * This should be used by a framework implementation to calculate the values for
-   * [[_ViewDeclaration.$uiViewName]] and [[_ViewDeclaration.$uiViewContextAnchor]].
+   * [[_ViewDeclaration.$ngViewName]] and [[_ViewDeclaration.$ngViewContextAnchor]].
    *
    * @param context the context object (state declaration) that the view belongs to
    * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
    *
-   * @returns the normalized uiViewName and uiViewContextAnchor that the view targets
+   * @returns the normalized ngViewName and ngViewContextAnchor that the view targets
    */
   static normalizeUIViewTarget(context, rawViewName = "") {
     // TODO: Validate incoming view name with a regexp to allow:
     // ex: "view.name@foo.bar" , "^.^.view.name" , "view.name@^.^" , "" ,
     // "@" , "$default@^" , "!$default.$default" , "!foo.bar"
     const viewAtContext = rawViewName.split("@");
-    let uiViewName = viewAtContext[0] || "$default"; // default to unnamed view
-    let uiViewContextAnchor = isString(viewAtContext[1])
+    let ngViewName = viewAtContext[0] || "$default"; // default to unnamed view
+    let ngViewContextAnchor = isString(viewAtContext[1])
       ? viewAtContext[1]
       : "^"; // default to parent context
     // Handle relative view-name sugar syntax.
     // Matches rawViewName "^.^.^.foo.bar" into array: ["^.^.^.foo.bar", "^.^.^", "foo.bar"],
-    const relativeViewNameSugar = /^(\^(?:\.\^)*)\.(.*$)/.exec(uiViewName);
+    const relativeViewNameSugar = /^(\^(?:\.\^)*)\.(.*$)/.exec(ngViewName);
     if (relativeViewNameSugar) {
       // Clobbers existing contextAnchor (rawViewName validation will fix this)
-      uiViewContextAnchor = relativeViewNameSugar[1]; // set anchor to "^.^.^"
-      uiViewName = relativeViewNameSugar[2]; // set view-name to "foo.bar"
+      ngViewContextAnchor = relativeViewNameSugar[1]; // set anchor to "^.^.^"
+      ngViewName = relativeViewNameSugar[2]; // set view-name to "foo.bar"
     }
-    if (uiViewName.charAt(0) === "!") {
-      uiViewName = uiViewName.substr(1);
-      uiViewContextAnchor = ""; // target absolutely from root
+    if (ngViewName.charAt(0) === "!") {
+      ngViewName = ngViewName.substr(1);
+      ngViewContextAnchor = ""; // target absolutely from root
     }
     // handle parent relative targeting "^.^.^"
     const relativeMatch = /^(\^(?:\.\^)*)$/;
-    if (relativeMatch.exec(uiViewContextAnchor)) {
-      const anchorState = uiViewContextAnchor
+    if (relativeMatch.exec(ngViewContextAnchor)) {
+      const anchorState = ngViewContextAnchor
         .split(".")
         .reduce((anchor, x) => anchor.parent, context);
-      uiViewContextAnchor = anchorState.name;
-    } else if (uiViewContextAnchor === ".") {
-      uiViewContextAnchor = context.name;
+      ngViewContextAnchor = anchorState.name;
+    } else if (ngViewContextAnchor === ".") {
+      ngViewContextAnchor = context.name;
     }
-    return { uiViewName, uiViewContextAnchor };
+    return { ngViewName, ngViewContextAnchor };
   }
 
   _rootViewContext(context) {
@@ -125,18 +127,18 @@ export class ViewService {
     this._viewConfigs.push(viewConfig);
   }
   sync() {
-    const uiViewsByFqn = this._uiViews
+    const ngViewsByFqn = this._ngViews
       .map((uiv) => [uiv.fqn, uiv])
       .reduce(applyPairs, {});
-    // Return a weighted depth value for a uiView.
+    // Return a weighted depth value for a ngView.
     // The depth is the nesting depth of ui-views (based on FQN; times 10,000)
-    // plus the depth of the state that is populating the uiView
-    function uiViewDepth(uiView) {
+    // plus the depth of the state that is populating the ngView
+    function ngViewDepth(ngView) {
       const stateDepth = (context) =>
         context && context.parent ? stateDepth(context.parent) + 1 : 1;
       return (
-        uiView.fqn.split(".").length * 10000 +
-        stateDepth(uiView.creationContext)
+        ngView.fqn.split(".").length * 10000 +
+        stateDepth(ngView.creationContext)
       );
     }
     // Return the ViewConfig's context's depth in the context tree.
@@ -151,34 +153,34 @@ export class ViewService {
       (depthFn, posNeg, left, right) =>
         posNeg * (depthFn(left) - depthFn(right)),
     );
-    const matchingConfigPair = (uiView) => {
+    const matchingConfigPair = (ngView) => {
       const matchingConfigs = this._viewConfigs.filter(
-        ViewService.matches(uiViewsByFqn, uiView),
+        ViewService.matches(ngViewsByFqn, ngView),
       );
       if (matchingConfigs.length > 1) {
         // This is OK.  Child states can target a ui-view that the parent state also targets (the child wins)
         // Sort by depth and return the match from the deepest child
-        // console.log(`Multiple matching view configs for ${uiView.fqn}`, matchingConfigs);
+        // console.log(`Multiple matching view configs for ${ngView.fqn}`, matchingConfigs);
         matchingConfigs.sort(depthCompare(viewConfigDepth, -1)); // descending
       }
-      return { uiView, viewConfig: matchingConfigs[0] };
+      return { ngView, viewConfig: matchingConfigs[0] };
     };
     const configureUIView = (tuple) => {
       // If a parent ui-view is reconfigured, it could destroy child ui-views.
-      // Before configuring a child ui-view, make sure it's still in the active uiViews array.
-      if (this._uiViews.indexOf(tuple.uiView) !== -1)
-        tuple.uiView.configUpdated(tuple.viewConfig);
+      // Before configuring a child ui-view, make sure it's still in the active ngViews array.
+      if (this._ngViews.indexOf(tuple.ngView) !== -1)
+        tuple.ngView.configUpdated(tuple.viewConfig);
     };
     // Sort views by FQN and state depth. Process uiviews nearest the root first.
-    const uiViewTuples = this._uiViews
-      .sort(depthCompare(uiViewDepth, 1))
+    const ngViewTuples = this._ngViews
+      .sort(depthCompare(ngViewDepth, 1))
       .map(matchingConfigPair);
-    const matchedViewConfigs = uiViewTuples.map((tuple) => tuple.viewConfig);
+    const matchedViewConfigs = ngViewTuples.map((tuple) => tuple.viewConfig);
     const unmatchedConfigTuples = this._viewConfigs
       .filter((config) => !inArray(matchedViewConfigs, config))
-      .map((viewConfig) => ({ uiView: undefined, viewConfig }));
-    uiViewTuples.forEach(configureUIView);
-    const allTuples = uiViewTuples.concat(unmatchedConfigTuples);
+      .map((viewConfig) => ({ ngView: undefined, viewConfig }));
+    ngViewTuples.forEach(configureUIView);
+    const allTuples = ngViewTuples.concat(unmatchedConfigTuples);
     this._listeners.forEach((cb) => cb(allTuples));
     trace.traceViewSync(allTuples);
   }
@@ -194,29 +196,29 @@ export class ViewService {
    * Note: There is no corresponding `deregisterUIView`.
    *       A `ui-view` should hang on to the return value of `registerUIView` and invoke it to deregister itself.
    *
-   * @param uiView The metadata for a UIView
+   * @param ngView The metadata for a UIView
    * @return a de-registration function used when the view is destroyed.
    */
-  registerUIView(uiView) {
-    trace.traceViewServiceUIViewEvent("-> Registering", uiView);
-    const uiViews = this._uiViews;
+  registerUIView(ngView) {
+    trace.traceViewServiceUIViewEvent("-> Registering", ngView);
+    const ngViews = this._ngViews;
     const fqnAndTypeMatches = (uiv) =>
-      uiv.fqn === uiView.fqn && uiv.$type === uiView.$type;
-    if (uiViews.filter(fqnAndTypeMatches).length)
-      trace.traceViewServiceUIViewEvent("!!!! duplicate uiView named:", uiView);
-    uiViews.push(uiView);
+      uiv.fqn === ngView.fqn && uiv.$type === ngView.$type;
+    if (ngViews.filter(fqnAndTypeMatches).length)
+      trace.traceViewServiceUIViewEvent("!!!! duplicate ngView named:", ngView);
+    ngViews.push(ngView);
     this.sync();
     return () => {
-      const idx = uiViews.indexOf(uiView);
+      const idx = ngViews.indexOf(ngView);
       if (idx === -1) {
         trace.traceViewServiceUIViewEvent(
-          "Tried removing non-registered uiView",
-          uiView,
+          "Tried removing non-registered ngView",
+          ngView,
         );
         return;
       }
-      trace.traceViewServiceUIViewEvent("<- Deregistering", uiView);
-      removeFrom(uiViews)(uiView);
+      trace.traceViewServiceUIViewEvent("<- Deregistering", ngView);
+      removeFrom(ngViews)(ngView);
     };
   }
   /**
@@ -225,7 +227,7 @@ export class ViewService {
    * @return {Array} Returns an array of fully-qualified view names.
    */
   available() {
-    return this._uiViews.map(prop("fqn"));
+    return this._ngViews.map(prop("fqn"));
   }
   /**
    * Returns the list of views on the page containing loaded content.
@@ -233,7 +235,7 @@ export class ViewService {
    * @return {Array} Returns an array of fully-qualified view names.
    */
   active() {
-    return this._uiViews.filter(prop("$config")).map(prop("name"));
+    return this._ngViews.filter(prop("$config")).map(prop("name"));
   }
 }
 /**
@@ -269,7 +271,7 @@ export class ViewService {
  *   </ui-view>
  * </ui-view>
  *
- * uiViews: [
+ * ngViews: [
  *  { fqn: "$default",                  creationContext: { name: "" } },
  *  { fqn: "$default.foo",              creationContext: { name: "A" } },
  *  { fqn: "$default.foo.$default",     creationContext: { name: "A.B" } }
@@ -278,10 +280,10 @@ export class ViewService {
  *
  * These four view configs all match the ui-view with the fqn: "$default.foo.$default.bar":
  *
- * - ViewConfig1: { uiViewName: "bar",                       uiViewContextAnchor: "A.B.C" }
- * - ViewConfig2: { uiViewName: "$default.bar",              uiViewContextAnchor: "A.B" }
- * - ViewConfig3: { uiViewName: "foo.$default.bar",          uiViewContextAnchor: "A" }
- * - ViewConfig4: { uiViewName: "$default.foo.$default.bar", uiViewContextAnchor: "" }
+ * - ViewConfig1: { ngViewName: "bar",                       ngViewContextAnchor: "A.B.C" }
+ * - ViewConfig2: { ngViewName: "$default.bar",              ngViewContextAnchor: "A.B" }
+ * - ViewConfig3: { ngViewName: "foo.$default.bar",          ngViewContextAnchor: "A" }
+ * - ViewConfig4: { ngViewName: "$default.foo.$default.bar", ngViewContextAnchor: "" }
  *
  * Using ViewConfig3 as an example, it matches the ui-view with fqn "$default.foo.$default.bar" because:
  * - The ViewConfig's segmented target name is: [ "foo", "$default", "bar" ]
@@ -293,13 +295,13 @@ export class ViewService {
  *
  * @internal
  */
-ViewService.matches = (uiViewsByFqn, uiView) => (viewConfig) => {
+ViewService.matches = (ngViewsByFqn, ngView) => (viewConfig) => {
   // Don't supply an ng1 ui-view with an ng2 ViewConfig, etc
-  if (uiView.$type !== viewConfig.viewDecl.$type) return false;
-  // Split names apart from both viewConfig and uiView into segments
+  if (ngView.$type !== viewConfig.viewDecl.$type) return false;
+  // Split names apart from both viewConfig and ngView into segments
   const vc = viewConfig.viewDecl;
-  const vcSegments = vc.$uiViewName.split(".");
-  const uivSegments = uiView.fqn.split(".");
+  const vcSegments = vc.$ngViewName.split(".");
+  const uivSegments = ngView.fqn.split(".");
   // Check if the tails of the segment arrays match. ex, these arrays' tails match:
   // vc: ["foo", "bar"], uiv fqn: ["$default", "foo", "bar"]
   if (!equals(vcSegments, uivSegments.slice(0 - vcSegments.length)))
@@ -308,6 +310,6 @@ ViewService.matches = (uiViewsByFqn, uiView) => (viewConfig) => {
   // ["$default", "foo"].join(".") == "$default.foo", does the ui-view $default.foo context match?
   const negOffset = 1 - vcSegments.length || undefined;
   const fqnToFirstSegment = uivSegments.slice(0, negOffset).join(".");
-  const uiViewContext = uiViewsByFqn[fqnToFirstSegment].creationContext;
-  return vc.$uiViewContextAnchor === (uiViewContext && uiViewContext.name);
+  const ngViewContext = ngViewsByFqn[fqnToFirstSegment].creationContext;
+  return vc.$ngViewContextAnchor === (ngViewContext && ngViewContext.name);
 };

package/src/services/browser.js

@@ -102,11 +102,7 @@ export function Browser($log, $$taskTrackerFactory) {
       //   lastBrowserUrl && stripHash(lastBrowserUrl) === stripHash(url);
       lastBrowserUrl = url;
       lastHistoryState = state;
-      // Don't use history API if only the hash changed
-      // due to a bug in IE10/IE11 which leads
-      // to not firing a `hashchange` nor `popstate` event
-      // in some cases (see #9143).
-      history[replace ? "replaceState" : "pushState"](state, "", url);
+      history.pushState(state, "", url);
       cacheState();
       return self;
       // getter

package/src/shared/common.js

@@ -1,5 +1,5 @@
 /**
- * Random utility functions used in the UI-Router code
+ * Random utility functions used in the ng-router code
  *
  * These functions are exported, but are subject to change without notice.
  *