INTERNAL BREAKING CHANGE: Move html5Mode and hashPrefix to LocationServices from LocationConfig

refactor(vanilla): Rewrite Location Services/Config as es6 classes

Author: christopherthielen

src/common/common.ts

@@ -140,6 +140,12 @@ export const removeFrom = curry((array: any[], obj: any) => {
 export const pushTo = <T> (arr: T[], val: T) =>
     (arr.push(val), val);
 
+/** Given an array of (deregistration) functions, calls all functions and removes each one from the source array */
+export const deregAll = (functions: Function[]) =>
+    functions.slice().forEach(fn => {
+      typeof fn === 'function' && fn();
+      removeFrom(functions, fn);
+    });
 /**
  * Applies a set of defaults to an options object.  The options object is filtered
  * to only those properties of the objects in the defaultsList.

src/common/coreservices.ts

@@ -61,9 +61,12 @@ export interface CoreServices {
 export interface LocationServices {
   setUrl(newurl: string, replace?: boolean): void;
   path(): string;
-  search(): string;
+  search(): { [key: string]: any };
   hash(): string;
   onChange(callback: Function): Function;
+  html5Mode(): boolean;
+  hashPrefix(): string;
+  hashPrefix(newprefix: string): string;
 }
 
 export interface LocationConfig {
@@ -72,9 +75,6 @@ export interface LocationConfig {
   host(): string;
 
   baseHref(): string;
-  html5Mode(): boolean;
-  hashPrefix(): string;
-  hashPrefix(newprefix: string): string;
 }
 
 export interface TemplateServices {

src/router.ts

@@ -9,6 +9,7 @@ import { StateService } from "./state/stateService";
 import { UIRouterGlobals, Globals } from "./globals";
 import { UIRouterPlugin, Disposable } from "./interface";
 import { values, removeFrom } from "./common/common";
+import { isFunction } from "./common/predicates";
 
 /** @hidden */
 let _routerInstance = 0;
@@ -51,7 +52,22 @@ export class UIRouter {
     this._disposables.push(disposable);
   }
 
-  dispose() {
+  /**
+   * 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.
+   *
+   * @param disposable (optional) the disposable to dispose
+   */
+  dispose(disposable?: any): void {
+    if (disposable && isFunction(disposable.dispose)) {
+      disposable.dispose(this);
+      return undefined;
+    }
+
     this._disposables.slice().forEach(d => {
       try {
         typeof d.dispose === 'function' && d.dispose(this);

src/transition/transitionService.ts

@@ -133,10 +133,10 @@ export class TransitionService implements IHookRegistry, Disposable {
   }
 
   /** @internalapi */
-  dispose() {
-    delete this._router.globals.transition;
+  dispose(router: UIRouter) {
+    delete router.globals.transition;
 
-    values(this._transitionHooks).forEach(hooksArray => hooksArray.forEach(hook => {
+    values(this._transitionHooks).forEach((hooksArray: RegisteredHook[]) => hooksArray.forEach(hook => {
       hook._deregistered = true;
       removeFrom(hooksArray, hook);
     }));

src/url/urlRouter.ts

@@ -380,7 +380,7 @@ export class UrlRouter implements Disposable {
    * @param params
    * @param options
    */
-  push(urlMatcher: UrlMatcher, params: StateParams, options: { replace?: (string|boolean) }) {
+  push(urlMatcher: UrlMatcher, params: RawParams, options: { replace?: (string|boolean) }) {
     let replace = options && !!options.replace;
     services.location.setUrl(urlMatcher.format(params || {}), replace);
   }
@@ -411,9 +411,10 @@ export class UrlRouter implements Disposable {
     options = options || { absolute: false };
 
     let cfg = services.locationConfig;
-    let isHtml5 = cfg.html5Mode();
+    let loc = services.location;
+    let isHtml5 = loc.html5Mode();
     if (!isHtml5 && url !== null) {
-      url = "#" + cfg.hashPrefix() + url;
+      url = "#" + loc.hashPrefix() + url;
     }
     url = appendBasePath(url, isHtml5, options.absolute);
 

src/vanilla/browserLocationConfig.ts

@@ -0,0 +1,30 @@
+/** @internalapi @module vanilla */ /** */
+
+import { isDefined } from "../common/predicates";
+import { LocationConfig } from "../common/coreservices";
+
+/** A `LocationConfig` that delegates to the browser's `location` object */
+export class BrowserLocationConfig implements LocationConfig {
+  private _baseHref = undefined;
+
+  port() {
+    return parseInt(location.port);
+  }
+
+  protocol () {
+    return location.protocol;
+  }
+
+  host() {
+    return location.host;
+  }
+
+  baseHref(href?: string) {
+    return isDefined(href) ? this._baseHref = href : this._baseHref || this.applyDocumentBaseHref();
+  }
+
+  applyDocumentBaseHref() {
+    let baseTags = document.getElementsByTagName("base");
+    return this._baseHref = baseTags.length ? baseTags[0].href.substr(location.origin.length) : "";
+  }
+}

src/vanilla/hashLocation.ts

@@ -1,50 +1,55 @@
 /** @internalapi @module vanilla */ /** */
-import { isDefined } from '../common/module';
-import { LocationConfig, LocationServices } from '../common/coreservices';
-import { splitHash, splitQuery, trimHashVal, getParams, locationPluginFactory } from './utils';
-import { UIRouter } from '../router';
+import { isDefined } from "../common/module";
+import { LocationServices } from "../common/coreservices";
+import { splitHash, splitQuery, trimHashVal, getParams, locationPluginFactory } from "./utils";
+import { UIRouter } from "../router";
 import { LocationPlugin } from "./interface";
+import { pushTo, deregAll } from "../common/common";
+import { Disposable } from "../interface";
+import { BrowserLocationConfig } from "./browserLocationConfig";
 
-let hashPrefix: string = '';
-let baseHref: string = '';
-
-/** A `LocationConfig` that delegates to the browser's `location` object */
-export const hashLocationConfig: LocationConfig = {
-  port: () =>
-    parseInt(location.port),
-  protocol: () =>
-    location.protocol,
-  host: () =>
-    location.host,
-  baseHref: () =>
-    baseHref,
-  html5Mode: () =>
-    false,
-  hashPrefix: (newprefix?: string): string => {
+/** A `LocationServices` that uses the browser hash "#" to get/set the current location */
+export class HashLocationService implements LocationServices, Disposable {
+  private _listeners: Function[] = [];
+  private _hashPrefix = "";
+
+  hash() {
+      return splitHash(trimHashVal(location.hash))[1];
+  }
+
+  path() {
+      return splitHash(splitQuery(trimHashVal(location.hash))[0])[0];
+  }
+
+  search() {
+    return getParams(splitQuery(splitHash(trimHashVal(location.hash))[0])[1]);
+  }
+
+  setUrl(url: string, replace: boolean = true) {
+    if (isDefined(url)) location.hash = url;
+  };
+
+  onChange(cb: EventListener) {
+    window.addEventListener('hashchange', cb, false);
+    return pushTo(this._listeners, () => window.removeEventListener('hashchange', cb));
+  }
+
+  html5Mode() {
+    return false;
+  }
+
+  hashPrefix(newprefix?: string): string {
     if(isDefined(newprefix)) {
-      hashPrefix = newprefix;
+      this._hashPrefix = newprefix;
     }
-    return hashPrefix;
+    return this._hashPrefix;
   }
-};
 
-/** A `LocationServices` that uses the browser hash "#" to get/set the current location */
-export const hashLocationService: LocationServices = {
-  hash: () =>
-      splitHash(trimHashVal(location.hash))[1],
-  path: () =>
-      splitHash(splitQuery(trimHashVal(location.hash))[0])[0],
-  search: () =>
-    getParams(splitQuery(splitHash(trimHashVal(location.hash))[0])[1]),
-  setUrl: (url: string, replace: boolean = true) => {
-    if (url) location.hash = url;
-  },
-  onChange: (cb: EventListener) => {
-    window.addEventListener('hashchange', cb, false);
-    return () => window.removeEventListener('hashchange', cb);
+  dispose() {
+    deregAll(this._listeners);
   }
-};
+}
 
 /** A `UIRouterPlugin` uses the browser hash to get/set the current location */
 export const hashLocationPlugin: (router: UIRouter) => LocationPlugin =
-    locationPluginFactory('vanilla.hashBangLocation', hashLocationService, hashLocationConfig);
+    locationPluginFactory('vanilla.hashBangLocation', HashLocationService, BrowserLocationConfig);

src/vanilla/memoryLocation.ts

@@ -1,79 +1,98 @@
 /** @internalapi @module vanilla */ /** */
-import { services, isDefined } from '../common/module';
-import { LocationConfig, LocationServices } from '../common/coreservices';
-import { splitQuery, trimHashVal, getParams, splitHash, locationPluginFactory } from './utils';
-import { removeFrom, unnestR } from "../common/common";
+import { isDefined } from "../common/module";
+import { LocationConfig, LocationServices } from "../common/coreservices";
+import { splitQuery, getParams, splitHash, locationPluginFactory } from "./utils";
+import { removeFrom, unnestR, deregAll } from "../common/common";
 import { UIRouter } from "../router";
 import { LocationPlugin } from "./interface";
 import { isArray } from "../common/predicates";
+import { Disposable } from "../interface";
 
-var mlc;
 /** A `LocationConfig` mock that gets/sets all config from an in-memory object */
-export const memoryLocationConfig: LocationConfig = mlc = {
-  _hashPrefix: '',
-  _baseHref: '',
-  _port: 80,
-  _protocol: "http",
-  _host: "localhost",
+export class MemoryLocationConfig implements LocationConfig {
+  _baseHref = '';
+  _port = 80;
+  _protocol = "http";
+  _host = "localhost";
 
-  port: () => mlc._port,
-  protocol: () => mlc._protocol,
-  host: () => mlc._host,
-  baseHref: () => mlc._baseHref,
-  html5Mode: () => false,
-  hashPrefix: (newprefix?: string): string => {
-    if (isDefined(newprefix)) {
-      mlc._hashPrefix = newprefix;
-    }
-    return mlc._hashPrefix;
-  }
-};
+  port = () => this._port;
+  protocol = () => this._protocol;
+  host = () => this._host;
+  baseHref = () => this._baseHref;
+}
 
-var mls;
 /** A `LocationServices` that gets/sets the current location from an in-memory object */
-export const memoryLocationService: LocationServices = mls = {
-  _listeners: [],
-  _url: {
+export class MemoryLocationService implements LocationServices, Disposable {
+  _listeners: Function[] = [];
+  _hashPrefix = "";
+  _url = {
     path: '',
     search: {},
     hash: ''
-  },
-  _changed: (newval, oldval) => {
+  };
+
+  private _urlChanged(newval, oldval) {
     if (newval === oldval) return;
     let evt = new Event("locationchange");
     evt['url'] = newval;
-    mls._listeners.forEach(cb => cb(evt));
-  },
+    this._listeners.forEach(cb => cb(evt));
+  }
 
-  url: () => {
-    let s = mls._url.search;
-    let hash = mls._url.hash;
+  url() {
+    let s = this._url.search;
+    let hash = this._url.hash;
     let query = Object.keys(s).map(key => (isArray(s[key]) ? s[key] : [s[key]]) .map(val => key + "=" + val))
         .reduce(unnestR, [])
         .join("&");
 
-    return mls._url.path +
+    return this._url.path +
         (query ? "?" + query : "") +
         (hash ? "#" + hash : "");
-  },
-  hash: () => mls._url.hash,
-  path: () => mls._url.path,
-  search: () => mls._url.search,
-  setUrl: (url: string, replace: boolean = false) => {
+  }
+
+  hash() {
+    return this._url.hash;
+  }
+
+  path() {
+    return this._url.path;
+  }
+
+  search() {
+    return this._url.search;
+  }
+
+  html5Mode() {
+    return false;
+  }
+
+  hashPrefix(newprefix?: string): string {
+    return isDefined(newprefix) ? this._hashPrefix = newprefix : this._hashPrefix;
+  }
+
+  setUrl(url: string, replace: boolean = false) {
     if (isDefined(url)) {
       let path = splitHash(splitQuery(url)[0])[0];
       let hash = splitHash(url)[1];
       let search = getParams(splitQuery(splitHash(url)[0])[1]);
 
-      let oldval = mls.url();
-      mls._url = { path, search, hash };
-      let newval = mls.url();
-      mls._changed(newval, oldval);
+      let oldval = this.url();
+      this._url = { path, search, hash };
+      let newval = this.url();
+      this._urlChanged(newval, oldval);
     }
-  },
-  onChange: (cb: EventListener) => (mls._listeners.push(cb), () => removeFrom(mls._listeners, cb))
-};
+  }
+
+  onChange(cb: EventListener) {
+    this._listeners.push(cb);
+    return () => removeFrom(this._listeners, cb);
+  }
+  
+  dispose() {
+    deregAll(this._listeners);
+  }
+}
 
 /** A `UIRouterPlugin` that gets/sets the current location from an in-memory object */
 export const memoryLocationPlugin: (router: UIRouter) => LocationPlugin =
-    locationPluginFactory("vanilla.memoryLocation", memoryLocationService, memoryLocationConfig);
+    locationPluginFactory("vanilla.memoryLocation", MemoryLocationService, MemoryLocationConfig);