@angular-wave/angular.ts 0.0.27 → 0.0.29

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

@@ -1,40 +1,7 @@
 import { forEach, isDefined, isFunction, isObject } from "../../shared/utils";
 import { UrlMatcher } from "./url-matcher";
-import { DefType, Param } from "../params/param";
+import { ParamFactory } from "../params/param-factory";
 
-export class ParamFactory {
-  constructor(router) {
-    this.router = router;
-  }
-
-  fromConfig(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.CONFIG,
-      this.router.urlService.config,
-      state,
-    );
-  }
-  fromPath(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.PATH,
-      this.router.urlService.config,
-      state,
-    );
-  }
-  fromSearch(id, type, state) {
-    return new Param(
-      id,
-      type,
-      DefType.SEARCH,
-      this.router.urlService.config,
-      state,
-    );
-  }
-}
 /**
  * Factory for [[UrlMatcher]] instances.
  *
@@ -43,28 +10,20 @@ export class ParamFactory {
  */
 export class UrlMatcherFactory {
   // TODO: move implementations to UrlConfig (urlService.config)
-  constructor(router) {
-    this.router = router;
+  constructor(urlServiceConfig) {
+    this.urlServiceConfig = urlServiceConfig;
     /** Creates a new [[Param]] for a given location (DefType) */
-    this.paramFactory = new ParamFactory(this.router);
-    // TODO: Check if removal of this will break anything, then remove these
-    this.UrlMatcher = UrlMatcher;
-    this.Param = Param;
+    this.paramFactory = new ParamFactory(urlServiceConfig);
     /** @deprecated use [[UrlConfig.caseInsensitive]] */
-    this.caseInsensitive = (value) =>
-      this.router.urlService.config.caseInsensitive(value);
+    this.caseInsensitive = (value) => urlServiceConfig.caseInsensitive(value);
     /** @deprecated use [[UrlConfig.defaultSquashPolicy]] */
     this.defaultSquashPolicy = (value) =>
-      this.router.urlService.config.defaultSquashPolicy(value);
+      urlServiceConfig.defaultSquashPolicy(value);
     /** @deprecated use [[UrlConfig.strictMode]] */
-    this.strictMode = (value) =>
-      this.router.urlService.config.strictMode(value);
+    this.strictMode = (value) => urlServiceConfig.strictMode(value);
     /** @deprecated use [[UrlConfig.type]] */
     this.type = (name, definition, definitionFn) => {
-      return (
-        this.router.urlService.config.type(name, definition, definitionFn) ||
-        this
-      );
+      return urlServiceConfig.type(name, definition, definitionFn) || this;
     };
   }
   /**
@@ -75,7 +34,7 @@ export class UrlMatcherFactory {
    * @returns The UrlMatcher.
    */
   compile(pattern, config) {
-    const urlConfig = this.router.urlService.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;
@@ -110,7 +69,7 @@ export class UrlMatcherFactory {
   }
 
   $get() {
-    const urlConfig = this.router.urlService.config;
+    const urlConfig = this.urlServiceConfig;
     urlConfig.paramTypes.enqueue = false;
     urlConfig.paramTypes._flushTypeQueue();
     return this;

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

@@ -1,5 +1,6 @@
+import { EventBus } from "../../core/pubsub";
 import { stripLastPathElement } from "../../shared/strings";
-import { UrlRuleFactory } from "./url-rule";
+
 function appendBasePath(url, isHtml5, absolute, baseHref) {
   if (baseHref === "/") return url;
   if (isHtml5) return stripLastPathElement(baseHref) + url;
@@ -16,16 +17,19 @@ function appendBasePath(url, isHtml5, absolute, baseHref) {
  */
 export class UrlRouter {
   /**
-   *
-   * @param {import('../router').UIRouter} router
+   * @param {angular.UrlService} urlService
    */
-  constructor(router) {
-    this.router = router;
-    this.urlRuleFactory = new UrlRuleFactory(router);
+  constructor(urlService, urlRuleFactory, $locationProvider) {
+    this.urlService = urlService;
+    this.urlRuleFactory = urlRuleFactory;
+    this.$locationProvider = $locationProvider;
+    EventBus.subscribe("$urlRouter:update", () => {
+      this.update();
+    });
   }
-  /** Internal API. */
+
   update(read) {
-    const $url = this.router.urlService;
+    const $url = this.urlService;
     if (read) {
       this.location = $url.url();
       return;
@@ -34,8 +38,6 @@ export class UrlRouter {
     $url.url(this.location, true);
   }
   /**
-   * Internal API.
-   *
    * Pushes a new location to the browser history.
    *
    * @internal
@@ -45,7 +47,7 @@ export class UrlRouter {
    */
   push(urlMatcher, params, options) {
     const replace = options && !!options.replace;
-    this.router.urlService.url(urlMatcher.format(params || {}), replace);
+    this.urlService.url(urlMatcher.format(params || {}), replace);
   }
   /**
    * Builds and returns a URL with interpolated parameters
@@ -70,18 +72,30 @@ export class UrlRouter {
     let url = urlMatcher.format(params);
     if (url == null) return null;
     options = options || { absolute: false };
-    const cfg = this.router.urlService.config;
-    const isHtml5 = cfg.html5Mode();
+    const cfg = this.urlService.config;
+    const isHtml5 = this.urlService.html5Mode();
     if (!isHtml5 && url !== null) {
-      url = "#" + cfg.hashPrefix() + url;
+      url = "#" + this.$locationProvider.hashPrefix() + url;
     }
-    url = appendBasePath(url, isHtml5, options.absolute, cfg.baseHref());
+    url = appendBasePath(
+      url,
+      isHtml5,
+      options.absolute,
+      this.urlService.baseHref(),
+    );
     if (!options.absolute || !url) {
       return url;
     }
     const slash = !isHtml5 && url ? "/" : "";
-    const cfgPort = cfg.port();
+    const cfgPort = this.urlService.$location.port();
     const port = cfgPort === 80 || cfgPort === 443 ? "" : ":" + cfgPort;
-    return [cfg.protocol(), "://", cfg.host(), port, slash, url].join("");
+    return [
+      cfg.protocol(),
+      "://",
+      this.urlService.$location.host(),
+      port,
+      slash,
+      url,
+    ].join("");
   }
 }

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

@@ -13,12 +13,10 @@ import { StateObject } from "../state/state-object";
  * - [[StateObject]]
  */
 export class UrlRuleFactory {
-  constructor(router) {
-    this.router = router;
-  }
-
-  compile(str) {
-    return this.router.urlMatcherFactory.compile(str);
+  constructor(urlMatcherFactory, stateService, routerGlobals) {
+    this.urlMatcherFactory = urlMatcherFactory;
+    this.stateService = stateService;
+    this.routerGlobals = routerGlobals;
   }
 
   /**
@@ -30,11 +28,11 @@ export class UrlRuleFactory {
   create(what, handler) {
     const { isState, isStateDeclaration } = StateObject;
     const makeRule = pattern([
-      [isString, (_what) => makeRule(this.compile(_what))],
+      [isString, (_what) => makeRule(this.urlMatcherFactory.compile(_what))],
       [is(UrlMatcher), (_what) => this.fromUrlMatcher(_what, handler)],
       [
         or(isState, isStateDeclaration),
-        (_what) => this.fromState(_what, this.router),
+        (_what) => this.fromState(_what, this.stateService, this.routerGlobals),
       ],
       [is(RegExp), (_what) => this.fromRegExp(_what, handler)],
       [isFunction, (_what) => new BaseUrlRule(_what, handler)],
@@ -81,8 +79,7 @@ export class UrlRuleFactory {
    */
   fromUrlMatcher(urlMatcher, handler) {
     let _handler = handler;
-    if (isString(handler))
-      handler = this.router.urlMatcherFactory.compile(handler);
+    if (isString(handler)) handler = this.urlMatcherFactory.compile(handler);
     if (is(UrlMatcher)(handler)) _handler = (match) => handler.format(match);
     function matchUrlParamters(url) {
       const params = urlMatcher.exec(url.path, url.search, url.hash);
@@ -115,7 +112,7 @@ export class UrlRuleFactory {
    * // Starts a transition to 'foo' with params: { fooId: '123', barId: '456' }
    * ```
    */
-  fromState(stateOrDecl, router) {
+  fromState(stateOrDecl, stateService, globals) {
     const state = StateObject.isStateDeclaration(stateOrDecl)
       ? stateOrDecl.$$state()
       : stateOrDecl;
@@ -127,8 +124,7 @@ export class UrlRuleFactory {
      * and the new URL are already identical
      */
     const handler = (match) => {
-      const $state = router.stateService;
-      const globals = router.globals;
+      const $state = stateService;
       if (
         $state.href(state, match) !==
         $state.href(globals.current, globals.params)

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

@@ -62,14 +62,14 @@ function getHandlerFn(handler) {
  *
  * 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 `$urlService.rules` (see: [[UIRouter.urlService]], [[URLService.rules]])
  */
 export class UrlRules {
-  constructor(router) {
+  constructor(urlRuleFactory) {
     this._sortFn = defaultRuleSortFn;
     this._rules = [];
     this._id = 0;
-    this.urlRuleFactory = new UrlRuleFactory(router);
+    this.urlRuleFactory = urlRuleFactory;
   }
 
   /**

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

@@ -4,20 +4,16 @@ import { UrlRules } from "./url-rules";
 import { UrlConfig } from "./url-config";
 import { TargetState } from "../state/target-state";
 import { removeFrom } from "../../shared/common";
+
 /**
  * API for URL management
  */
 export class UrlService {
   /**
-   *
-   * @param {import('../router').UIRouter} router
    * @param {angular.ILocationProvider} $locationProvider
    */
-  constructor(router, $locationProvider) {
-    /**
-     * @type {import('../router').UIRouter}
-     */
-    this.router = router;
+  constructor($locationProvider, urlRuleFactory, stateService) {
+    this.stateService = stateService;
 
     this.$locationProvider = $locationProvider;
 
@@ -29,14 +25,14 @@ export class UrlService {
      * See: [[UrlRules]] for details
      * @type {UrlRules}
      */
-    this.rules = new UrlRules(this.router);
+    this.rules = new UrlRules(urlRuleFactory);
     /**
      * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
      *
      * See: [[UrlConfig]] for details
      * @type {UrlConfig}
      */
-    this.config = new UrlConfig(this.router);
+    this.config = new UrlConfig();
 
     /**
      * Gets the path part of the current url
@@ -188,15 +184,18 @@ export class UrlService {
    */
   sync(evt) {
     if (evt && evt.defaultPrevented) return;
-    const { urlService, stateService } = this.router;
+    const stateService = this.stateService;
     const url = {
-      path: urlService.path(),
-      search: urlService.search(),
-      hash: urlService.hash(),
+      path: this.path(),
+      search: this.search(),
+      hash: this.hash(),
     };
+    /**
+     * @type {angular.MatchResult}
+     */
     const best = this.match(url);
     const applyResult = pattern([
-      [isString, (newurl) => urlService.url(newurl, true)],
+      [isString, (newurl) => this.url(newurl, true)],
       [
         TargetState.isDef,
         (def) => stateService.go(def.state, def.params, def.options),
@@ -207,7 +206,8 @@ export class UrlService {
           stateService.go(target.state(), target.params(), target.options()),
       ],
     ]);
-    applyResult(best && best.rule.handler(best.match, url, this.router));
+
+    applyResult(best && best.rule.handler(best.match, url));
   }
   /**
    * Starts or stops listening for URL changes
@@ -237,8 +237,7 @@ export class UrlService {
       delete this._stopListeningFn;
     } else {
       return (this._stopListeningFn =
-        this._stopListeningFn ||
-        this.router.urlService.onChange((evt) => this.sync(evt)));
+        this._stopListeningFn || this.onChange((evt) => this.sync(evt)));
     }
   }
   /**
@@ -274,13 +273,18 @@ export class UrlService {
    *
    * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
    * Return the result as a [[MatchResult]].
+   * @returns {angular.MatchResult}
    */
   match(url) {
     url = Object.assign({ path: "", search: {}, hash: "" }, url);
     const rules = this.rules.rules();
     // Checks a single rule. Returns { rule: rule, match: match, weight: weight } if it matched, or undefined
+    /**
+     *
+     * @param {import("./url-rule").BaseUrlRule} rule
+     */
     const checkRule = (rule) => {
-      const match = rule.match(url, this.router);
+      const match = rule.match(url);
       return match && { match, rule, weight: rule.matchPriority(match) };
     };
     // The rules are pre-sorted.

package/src/router/view/view.js

@@ -26,10 +26,10 @@ import { trace } from "../common/trace";
  */
 export class ViewService {
   /**
-   * @param {import('../router').UIRouter} router
+   * @param {number} $id
    */
-  constructor(router) {
-    this._uiViews = [];
+  constructor($id) {
+    this._ngViews = [];
     this._viewConfigs = [];
     this._viewConfigFactories = {};
     this._listeners = [];
@@ -37,8 +37,8 @@ export class ViewService {
       _rootViewContext: this._rootViewContext.bind(this),
       _viewConfigFactory: this._viewConfigFactory.bind(this),
       _registeredUIView: (id) =>
-        find(this._uiViews, (view) => `${router.$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);
@@ -51,45 +51,45 @@ export class ViewService {
    * 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 +125,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 +151,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 +194,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 +225,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 +233,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 +269,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 +278,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 +293,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 +308,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/hof.js

@@ -77,7 +77,7 @@ export function compose() {
  * let piped = pipe(f,g,h);
  * then, piped is: h(g(f(x)))
  */
-export function pipe(...funcs) {
+export function pipe() {
   return compose.apply(null, [].slice.call(arguments).reverse());
 }
 /**

package/test/angular.spec.js

@@ -48,6 +48,7 @@ describe("angular", () => {
 
   afterEach(() => {
     dealoc(element);
+    jqLite.CACHE.clear();
   });
 
   describe("case", () => {