refactor(ParamTypes): Remove global registry instance variable

refactor(ng1.init): Set services.$q/$injector in ui.router.init ng1 module

Author: christopherthielen

src/ng1/services.ts

@@ -157,14 +157,6 @@ export function annotateController(controllerExpression: (IInjectable|string)):
   }
 }
 
-runBlock.$inject = ['$injector', '$q'];
-function runBlock($injector: IInjectorService, $q: IQService) {
-  services.$injector = $injector;
-  services.$q = $q;
-}
-
-app.run(runBlock);
-
 let router: UIRouter = null;
 
 $uiRouter.$inject = ['$locationProvider'];
@@ -222,6 +214,15 @@ function $uiRouter($locationProvider: ILocationProvider) {
 
 // The 'ui.router' ng1 module depends on 'ui.router.init' module.
 angular.module('ui.router.init', []).provider("$uiRouter", <any> $uiRouter);
+
+runBlock.$inject = ['$injector', '$q'];
+function runBlock($injector: IInjectorService, $q: IQService) {
+  services.$injector = $injector;
+  services.$q = $q;
+}
+
+angular.module('ui.router.init').run(runBlock);
+
 // This effectively calls $get() to init when we enter runtime
 angular.module('ui.router.init').run(['$uiRouter', function($uiRouter: UIRouter) { }]);
 

src/params/param.ts

@@ -6,7 +6,7 @@ import {RawParams, ParamDeclaration} from "../params/interface";
 import {services} from "../common/coreservices";
 import {matcherConfig} from "../url/urlMatcherConfig";
 import {ParamType} from "./type";
-import {paramTypes} from "./paramTypes";
+import {ParamTypes} from "./paramTypes";
 
 let hasOwn = Object.prototype.hasOwnProperty;
 let isShorthand = (cfg: ParamDeclaration) =>
@@ -24,7 +24,7 @@ function unwrapShorthand(cfg: ParamDeclaration): ParamDeclaration {
   });
 }
 
-function getType(cfg: ParamDeclaration, urlType: ParamType, location: DefType, id: string) {
+function getType(cfg: ParamDeclaration, urlType: ParamType, location: DefType, id: string, paramTypes: ParamTypes) {
   if (cfg.type && urlType && urlType.name !== 'string') throw new Error(`Param '${id}' has two type configurations.`);
   if (cfg.type && urlType && urlType.name === 'string' && paramTypes.type(cfg.type as string)) return paramTypes.type(cfg.type as string);
   if (urlType) return urlType;
@@ -66,9 +66,9 @@ export class Param {
   dynamic: boolean;
   config: any;
 
-  constructor(id: string, type: ParamType, config: ParamDeclaration, location: DefType) {
+  constructor(id: string, type: ParamType, config: ParamDeclaration, location: DefType, paramTypes: ParamTypes) {
     config = unwrapShorthand(config);
-    type = getType(config, type, location, id);
+    type = getType(config, type, location, id, paramTypes);
     let arrayMode = getArrayMode();
     type = arrayMode ? type.$asArray(arrayMode, location === DefType.SEARCH) : type;
     let isOptional = config.value !== undefined;
@@ -137,18 +137,18 @@ export class Param {
   }
 
   /** Creates a new [[Param]] from a CONFIG block */
-  static fromConfig(id: string, type: ParamType, config: any): Param {
-    return new Param(id, type, config, DefType.CONFIG);
+  static fromConfig(id: string, type: ParamType, config: any, paramTypes: ParamTypes): Param {
+    return new Param(id, type, config, DefType.CONFIG, paramTypes);
   }
 
   /** Creates a new [[Param]] from a url PATH */
-  static fromPath(id: string, type: ParamType, config: any): Param {
-    return new Param(id, type, config, DefType.PATH);
+  static fromPath(id: string, type: ParamType, config: any, paramTypes: ParamTypes): Param {
+    return new Param(id, type, config, DefType.PATH, paramTypes);
   }
 
   /** Creates a new [[Param]] from a url SEARCH */
-  static fromSearch(id: string, type: ParamType, config: any): Param {
-    return new Param(id, type, config, DefType.SEARCH);
+  static fromSearch(id: string, type: ParamType, config: any, paramTypes: ParamTypes): Param {
+    return new Param(id, type, config, DefType.SEARCH, paramTypes);
   }
 
   static values(params: Param[], values: RawParams = {}): RawParams {

src/params/paramTypes.ts

@@ -107,5 +107,3 @@ export class ParamTypes {
     }
   }
 }
-
-export let paramTypes = new ParamTypes();

src/state/stateBuilder.ts

@@ -13,6 +13,7 @@ import {UrlMatcher} from "../url/urlMatcher";
 import {Resolvable} from "../resolve/resolvable";
 import {services} from "../common/coreservices";
 import {ResolvePolicy} from "../resolve/interface";
+import {ParamTypes} from "../params/paramTypes";
 
 const parseUrl = (url: string): any => {
   if (!isString(url)) return false;
@@ -71,12 +72,13 @@ function navigableBuilder(state: State) {
   return !isRoot(state) && state.url ? state : (state.parent ? state.parent.navigable : null);
 };
 
+const getParamsBuilder = (paramTypes: ParamTypes) => 
 function paramsBuilder(state: State): { [key: string]: Param } {
-  const makeConfigParam = (config: any, id: string) => Param.fromConfig(id, null, config);
+  const makeConfigParam = (config: any, id: string) => Param.fromConfig(id, null, config, paramTypes);
   let urlParams: Param[] = (state.url && state.url.parameters({inherit: false})) || [];
   let nonUrlParams: Param[] = values(mapObj(omit(state.params || {}, urlParams.map(prop('id'))), makeConfigParam));
   return urlParams.concat(nonUrlParams).map(p => [p.id, p]).reduce(applyPairs, {});
-}
+};
 
 function pathBuilder(state: State) {
   return state.parent ? state.parent.path.concat(state) : /*root*/ [state];
@@ -217,7 +219,7 @@ export class StateBuilder {
       url: [ getUrlBuilder($urlMatcherFactoryProvider, root) ],
       // Keep track of the closest ancestor state that has a URL (i.e. is navigable)
       navigable: [ getNavigableBuilder(isRoot) ],
-      params: [ paramsBuilder ],
+      params: [ getParamsBuilder($urlMatcherFactoryProvider.paramTypes) ],
       // Each framework-specific ui-router implementation should define its own `views` builder
       // e.g., src/ng1/statebuilders/views.ts
       views: [],

src/url/urlMatcher.ts

@@ -6,7 +6,7 @@ import {
 import {prop, propEq } from "../common/hof";
 import {isArray, isString} from "../common/predicates";
 import {Param} from "../params/param";
-import {paramTypes} from "../params/paramTypes";
+import {ParamTypes} from "../params/paramTypes";
 import {isDefined} from "../common/predicates";
 import {DefType} from "../params/param";
 import {unnestR} from "../common/common";
@@ -112,11 +112,12 @@ export class UrlMatcher {
 
   /**
    * @param pattern The pattern to compile into a matcher.
+   * @param paramTypes The [[ParamTypes]] registry
    * @param config  A configuration object
    * - `caseInsensitive` - `true` if URL matching should be case insensitive, otherwise `false`, the default value (for backward compatibility) is `false`.
    * - `strict` - `false` if matching against a URL with a trailing slash should be treated as equivalent to a URL without a trailing slash, the default value is `true`.
    */
-  constructor(pattern: string, public config?: any) {
+  constructor(pattern: string, paramTypes: ParamTypes, public config?: any) {
     this.pattern = pattern;
     this.config = defaults(this.config, {
       params: {},
@@ -171,7 +172,7 @@ export class UrlMatcher {
       if (p.segment.indexOf('?') >= 0) break; // we're into the search part
 
       checkParamErrors(p.id);
-      this._params.push(Param.fromPath(p.id, p.type, this.config.paramMap(p.cfg, false)));
+      this._params.push(Param.fromPath(p.id, p.type, this.config.paramMap(p.cfg, false), paramTypes));
       this._segments.push(p.segment);
       patterns.push([p.segment, tail(this._params)]);
       last = placeholder.lastIndex;
@@ -191,7 +192,7 @@ export class UrlMatcher {
         while ((m = searchPlaceholder.exec(search))) {
           p = matchDetails(m, true);
           checkParamErrors(p.id);
-          this._params.push(Param.fromSearch(p.id, p.type, this.config.paramMap(p.cfg, true)));
+          this._params.push(Param.fromSearch(p.id, p.type, this.config.paramMap(p.cfg, true), paramTypes));
           last = placeholder.lastIndex;
           // check if ?&
         }

src/url/urlMatcherFactory.ts

@@ -5,8 +5,7 @@ import {isObject, isDefined, isFunction} from "../common/predicates";
 import {UrlMatcher} from "./urlMatcher";
 import {matcherConfig} from "./urlMatcherConfig";
 import {Param} from "../params/param";
-import {paramTypes} from "../params/paramTypes";
-import {ParamType} from "../params/type";
+import {ParamTypes} from "../params/paramTypes";
 import {ParamTypeDefinition} from "../params/interface";
 
 /** @hidden */
@@ -24,6 +23,8 @@ function getDefaultConfig() {
  * `$urlMatcherFactor` or ng1 providers as `$urlMatcherFactoryProvider`.
  */
 export class UrlMatcherFactory {
+  paramTypes = new ParamTypes();
+
   constructor() {
     extend(this, { UrlMatcher, Param });
   }
@@ -71,7 +72,7 @@ export class UrlMatcherFactory {
    * @returns The UrlMatcher.
    */
   compile(pattern: string, config?: { [key: string]: any }) {
-    return new UrlMatcher(pattern, extend(getDefaultConfig(), config));
+    return new UrlMatcher(pattern, this.paramTypes, extend(getDefaultConfig(), config));
   }
 
   /**
@@ -112,14 +113,14 @@ export class UrlMatcherFactory {
    * See [[ParamTypeDefinition]] for examples
    */
   type(name: string, definition?: ParamTypeDefinition, definitionFn?: () => ParamTypeDefinition) {
-    let type = paramTypes.type(name, definition, definitionFn);
+    let type = this.paramTypes.type(name, definition, definitionFn);
     return !isDefined(definition) ? type : this;
   };
 
   /** @hidden */
   $get() {
-    paramTypes.enqueue = false;
-    paramTypes._flushTypeQueue();
+    this.paramTypes.enqueue = false;
+    this.paramTypes._flushTypeQueue();
     return this;
   };
 }