feat(UIRouterConfig): Use a simple function to configure module instead of an injectable class

BREAKING CHANGE: You no longer configure a module using an Injectable `UIRouterConfig` class. Now you use a function that receives the `UIRouter` and the `Injector`

In 1.0.0-beta.3 you might have a config class like this:
```js
export class MyUIRouterConfig {
  constructor(@Inject(UIRouter) router: UIRouter, @Inject(SomeService) myService: SomeService) {
    // do something with router and injected service
  }
}

which was wired into the root module like this:
```js
@NgModule({
  imports: [
    UIRouterModule.forRoot({ configClass: MyUIRouterConfig })
  ]
})
export class AppModule {}
```

In 1.0.0-beta.4 you should switch to a simple function.
The function receives the router: `UIRouter` and injector: `Injector`
```js
export function configureModule(router: UIRouter, injector: Injector) {
  // do something with router
  router.urlService.rules.type('slug', slugParamType);
  // inject other services
  const myService: SomeService = injector.get(SomeService);
  // do something injected service
  myService.init();
}
```

which is now wired using `config: configureModule` instead of `configClass: ...`
```js
@NgModule({
  imports: [
    UIRouterModule.forRoot({ configClass: MyUIRouterConfig })
  ]
})
export class AppModule {}
```

Author: christopherthielen

src/uiRouterConfig.ts

@@ -1,12 +1,12 @@
 /** @module ng2 */ /** */
-import {UIRouter} from "ui-router-core";
+import { UIRouter, isFunction } from "ui-router-core";
 import {StatesModule, RootModule} from "./uiRouterNgModule";
 import {Injector} from "@angular/core";
 import {isDefined} from "ui-router-core";
 
-export function applyModuleConfig(uiRouter: UIRouter, injector: Injector, options: StatesModule) {
-  if (options.configClass) {
-    injector.get(options.configClass);
+export function applyModuleConfig(uiRouter: UIRouter, injector: Injector, options: StatesModule = {}) {
+  if (isFunction(options.config)) {
+    options.config(uiRouter, injector);
   }
 
   let states = options.states || [];

src/uiRouterNgModule.ts

@@ -2,12 +2,12 @@
 /** */
 import { Ng2StateDeclaration } from "./interface";
 import {
-  NgModule, OpaqueToken, ModuleWithProviders, ANALYZE_FOR_ENTRY_COMPONENTS, Provider, Type
+  NgModule, OpaqueToken, ModuleWithProviders, ANALYZE_FOR_ENTRY_COMPONENTS, Provider, Injector
 } from "@angular/core";
 import { CommonModule, LocationStrategy, HashLocationStrategy, PathLocationStrategy } from "@angular/common";
 import { _UIROUTER_DIRECTIVES } from "./directives/directives";
 import { UIView } from "./directives/uiView";
-import { UrlRuleHandlerFn, TargetState, TargetStateDef } from "ui-router-core";
+import { UrlRuleHandlerFn, TargetState, TargetStateDef, UIRouter } from "ui-router-core";
 import { _UIROUTER_INSTANCE_PROVIDERS, _UIROUTER_SERVICE_PROVIDERS } from "./providers";
 
 // import { ROUTES } from "@angular/router/src/router_config_loader";
@@ -189,43 +189,45 @@ export interface StatesModule {
   /**
    * A UI-Router Module's imperative configuration
    *
-   * If a UI-Router Module needs to perform some configuration (such as registering parameter types or Transition Hooks)
-   * a `configClass` should be supplied.
+   * If a UI-Router Module needs to perform some configuration (such as registering
+   * parameter types or Transition Hooks) a `configFn` should be supplied.
+   * The function will be passed the `UIRouter` instance and the module's `Injector`
    *
-   * Mark the class as `@Injectable()` and inject any required dependencies.
-   * When the module is being loaded, an instance will be created and injected.
-   *
-   * Example:
+   * #### Example:
    * ```js
-   * @Injectable()
-   * export class MyUIRouterConfig {
-   *   // The constructor may be injected
-   *   constructor(uiRouter: UIRouter) {
-   *     const requireAuthentication = (transition: Transition) => {
-   *       let injector = transition.injector();
-   *       if (!injector.get(AuthService).isAuthenticated()) {
-   *         return uiRouter.stateService.target('login');
-   *       }
-   *     }
-   *
-   *     uiRouter.transitionService.onBefore({ to: (state) => state.requiresAuth }, requireAuthentication);
-   *
-   *     let builtInStringType = urlMatcherFactory.type('string');
-   *     let slugType = Object.assign({}, builtInStringType, { encode: (str) => str, decode: (str) => str });
-   *     uiRouter.urlMatcherFactory.type('slug', slugType);
-   *   }
+   * import { Injector } from "@angular/core";
+   * import { UIRouter } from "ui-router-ng2";
+   * import { requireAuthHook } from "./requireAuthHook";
+   * import { MyService } from "./myService";
+   *
+   * export function configureMyModule(uiRouter: UIRouter, injector: Injector) {
+   *   // Get UIRouter services off the UIRouter object
+   *   let urlConfig = uiRouter.urlService.config;
+   *   let transitionService = uiRouter.transitionService;
+   *   uiRouter.trace.enable("TRANSITION");
+   *
+   *   transitionService.onBefore({ to: (state) => state.requiresAuth }, requireAuthHook);
+   *
+   *   // Create a slug type based on the string type
+   *   let builtInStringType = urlConfig.type('string');
+   *   let slugType = Object.assign({}, builtInStringType, { encode: (str) => str, decode: (str) => str });
+   *   urlConfig.type('slug', slugType);
+   *
+   *   // Inject arbitrary services from DI using the Injector argument
+   *   let myService: MyService = injector.get(MyService)
+   *   myService.useFastMode();
    * }
    * ```
    *
    * ```js
    * @NgModule({
    *   imports: [
-   *     UIRouterModule.forChild({ states: STATES, configClass: MyUIRouterConfig });
+   *     UIRouterModule.forChild({ states: STATES, config: configureMyModule });
    *   ]
    * })
    * class MyModule {}
    * ```
    */
-  configClass?: Type<any>;
+  config?: (uiRouterInstance: UIRouter, injector: Injector) => any;
 }