fix(ng2.NgModule): Allow apps with no forChild modules

fix(ResolveContext): Scope native injector in resolve tree.
- Build injector() using scoped native injector
refactor(ng2.NgModule): Switch from NG2_INJECTOR_TOKEN to NATIVE_INJECTOR_TOKEN
- Move token to core

Closes #3009

src/ng2/directives/uiView.ts

@@ -7,9 +7,8 @@ import {
 import {UIRouter} from "../../router";
 import {trace} from "../../common/trace";
 import {ViewContext, ViewConfig, ActiveUIView} from "../../view/interface";
-import {NG2_INJECTOR_TOKEN} from "../interface";
 import {Ng2ViewConfig} from "../statebuilders/views";
-import {ResolveContext} from "../../resolve/resolveContext";
+import {ResolveContext, NATIVE_INJECTOR_TOKEN} from "../../resolve/resolveContext";
 import {flattenR} from "../../common/common";
 import {MergeInjector} from "../mergeInjector";
 
@@ -227,7 +226,7 @@ export class UIView {
  newProviders.push({ provide: UIView.PARENT_INJECT, useValue: parentInject });
 
  let parentComponentInjector = this.viewContainerRef.injector;
- let moduleInjector = context.getResolvable(NG2_INJECTOR_TOKEN).data;
+ let moduleInjector = context.getResolvable(NATIVE_INJECTOR_TOKEN).data;
  let mergedParentInjector = new MergeInjector(moduleInjector, parentComponentInjector);
 
  return ReflectiveInjector.resolveAndCreate(newProviders, mergedParentInjector);

src/ng2/lazyLoadNgModule.ts

@@ -1,14 +1,14 @@
 /** @module ng2 */ /** */
 import {NgModuleFactoryLoader, NgModuleRef, Injector, NgModuleFactory} from "@angular/core";
 
-import {NG2_INJECTOR_TOKEN} from "./interface";
 import {LazyLoadResult} from "../state/interface";
 
 import {Transition} from "../transition/transition";
-import {RootModule, ChildModule, UIROUTER_ROOT_MODULE, UIROUTER_CHILD_MODULE} from "./uiRouterNgModule";
+import {RootModule, StatesModule, UIROUTER_ROOT_MODULE, UIROUTER_MODULE_TOKEN} from "./uiRouterNgModule";
 import {applyModuleConfig} from "./uiRouterConfig";
 import {UIRouter} from "../router";
 import {Resolvable} from "../resolve/resolvable";
+import {NATIVE_INJECTOR_TOKEN} from "../resolve/resolveContext";
 
 /**
  * Returns a function which lazy loads a nested module
@@ -27,7 +27,7 @@ import {Resolvable} from "../resolve/resolvable";
 export function loadNgModule(path: string): (transition: Transition) => Promise<LazyLoadResult> {
  /** Get the parent NgModule Injector (from resolves) */
  const getNg2Injector = (transition: Transition) =>
- transition.injector().getAsync(NG2_INJECTOR_TOKEN);
+ transition.injector().getAsync(NATIVE_INJECTOR_TOKEN);
 
  /**
  * Lazy loads the NgModule using the NgModuleFactoryLoader
@@ -70,16 +70,16 @@ export function loadNgModule(path: string): (transition: Transition) => Promise<
  throw new Error('Lazy loaded modules should not contain a UIRouterModule.forRoot() module');
  }
 
- let childModules: ChildModule[] = injector.get(UIROUTER_CHILD_MODULE);
- childModules.forEach(module => applyModuleConfig(uiRouter, injector, module));
+ let modules: StatesModule[] = injector.get(UIROUTER_MODULE_TOKEN);
+ modules.forEach(module => applyModuleConfig(uiRouter, injector, module));
 
  let replacementState = uiRouter.stateRegistry.get(originalName);
  if (replacementState === originalState) {
  throw new Error(`The module that was loaded from ${path} should have a ui-router state named '${originalName}'`);
  }
 
  // Supply the newly loaded states with the Injector from the lazy loaded NgModule
- replacementState.$$state().resolvables.push(Resolvable.fromData(NG2_INJECTOR_TOKEN, injector));
+ replacementState.$$state().resolvables.push(Resolvable.fromData(NATIVE_INJECTOR_TOKEN, injector));
 
  return {};
  }

src/ng2/providers.ts

@@ -95,14 +95,15 @@ import {UrlRouter} from "../url/urlRouter";
 import {ViewService} from "../view/view";
 import {UIView, ParentUIViewInject} from "./directives/uiView";
 import {ng2ViewsBuilder, Ng2ViewConfig} from "./statebuilders/views";
-import {Ng2ViewDeclaration, NG2_INJECTOR_TOKEN} from "./interface";
+import {Ng2ViewDeclaration} from "./interface";
 import {applyRootModuleConfig, applyModuleConfig} from "./uiRouterConfig";
 import {Globals} from "../globals";
 import {UIRouterLocation} from "./location";
 import {services} from "../common/coreservices";
 import {Resolvable} from "../resolve/resolvable";
-import {RootModule, ChildModule, UIROUTER_ROOT_MODULE, UIROUTER_CHILD_MODULE} from "./uiRouterNgModule";
+import {RootModule, StatesModule, UIROUTER_ROOT_MODULE, UIROUTER_MODULE_TOKEN} from "./uiRouterNgModule";
 import {UIRouterRx} from "./rx";
+import {NATIVE_INJECTOR_TOKEN} from "../resolve/resolveContext";
 
 /**
  * This is a factory function for a UIRouter instance
@@ -115,7 +116,7 @@ let uiRouterFactory = (
  injector: Injector) => {
 
  let rootModules: RootModule[] = injector.get(UIROUTER_ROOT_MODULE);
- let childModules: ChildModule[] = injector.get(UIROUTER_CHILD_MODULE);
+ let modules: StatesModule[] = injector.get(UIROUTER_MODULE_TOKEN);
 
  if (rootModules.length !== 1) {
  throw new Error("Exactly one UIRouterModule.forRoot() should be in the bootstrapped app module's imports: []");
@@ -144,7 +145,7 @@ let uiRouterFactory = (
  registry.stateQueue.flush(router.stateService);
 
  // Prep the tree of NgModule by placing the root NgModule's Injector on the root state.
- let ng2InjectorResolvable = Resolvable.fromData(NG2_INJECTOR_TOKEN, injector);
+ let ng2InjectorResolvable = Resolvable.fromData(NATIVE_INJECTOR_TOKEN, injector);
  registry.root().resolvables.push(ng2InjectorResolvable);
 
 
@@ -154,7 +155,7 @@ let uiRouterFactory = (
 
  setTimeout(() => {
  rootModules.forEach(moduleConfig => applyRootModuleConfig(router, injector, moduleConfig));
- childModules.forEach(moduleConfig => applyModuleConfig(router, injector, moduleConfig));
+ modules.forEach(moduleConfig => applyModuleConfig(router, injector, moduleConfig));
 
  // Start monitoring the URL
  if (!router.urlRouterProvider.interceptDeferred) {

src/ng2/uiRouterConfig.ts

@@ -1,10 +1,10 @@
 /** @module ng2 */ /** */
 import {UIRouter} from "../router";
-import {ChildModule, RootModule} from "./uiRouterNgModule";
+import {StatesModule, RootModule} from "./uiRouterNgModule";
 import {Injector} from "@angular/core";
 import {isDefined} from "../common/predicates";
 
-export function applyModuleConfig(uiRouter: UIRouter, injector: Injector, options: ChildModule) {
+export function applyModuleConfig(uiRouter: UIRouter, injector: Injector, options: StatesModule) {
  if (options.configClass) {
  injector.get(options.configClass);
  }
@@ -29,8 +29,6 @@ export function applyRootModuleConfig(uiRouter: UIRouter, injector: Injector, co
  uiRouter.urlRouterProvider.otherwise(<any> config.otherwise);
  }
  }
-
- applyModuleConfig(uiRouter, injector, config);
 }
 
 

src/ng2/uiRouterNgModule.ts

@@ -110,31 +110,30 @@ export class UIRouterModule {
  * @param module UI-Router module options
  * @returns an `NgModule`
  */
- static forChild(module: ChildModule = {}): ModuleWithProviders {
+ static forChild(module: StatesModule = {}): ModuleWithProviders {
  return {
  ngModule: UIRouterModule,
  providers: UIRouterModule.makeProviders(module, false),
  }
  }
 
- static makeProviders(module: ChildModule, forRoot: boolean): Provider[] {
- let provideConfig: Provider[] = [module.configClass]
+ static makeProviders(module: StatesModule, forRoot: boolean): Provider[] {
+ let providers: Provider[] = [module.configClass]
  .filter(identity)
  .map(configClass => ({ provide: configClass, useClass: configClass }));
 
- let UIROUTER_MODULE_TOKEN = forRoot ? UIROUTER_ROOT_MODULE : UIROUTER_CHILD_MODULE;
+ if (forRoot) providers.push({ provide: UIROUTER_ROOT_MODULE, useValue: module, multi: true});
+ providers.push({ provide: UIROUTER_MODULE_TOKEN, useValue: module, multi: true });
+ providers.push({ provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: module.states || [], multi: true });
 
- return provideConfig.concat([
- { provide: UIROUTER_MODULE_TOKEN, useValue: module, multi: true },
- { provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: module.states || [], multi: true },
- ]);
+ return providers;
  }
 }
 
 /**
  * UI-Router declarative configuration which can be provided to [[UIRouterModule.forRoot]]
  */
-export interface RootModule extends ChildModule {
+export interface RootModule extends StatesModule {
  /**
  * Chooses a `LocationStrategy`.
  *
@@ -162,7 +161,7 @@ export interface RootModule extends ChildModule {
 /**
  * UI-Router Module declarative configuration which can be passed to [[UIRouterModule.forChild]]
  */
-export interface ChildModule {
+export interface StatesModule {
  /**
  * The module's UI-Router states
  *
@@ -214,6 +213,6 @@ export interface ChildModule {
  configClass?: Type<any>;
 }
 
-export const UIROUTER_ROOT_MODULE = new OpaqueToken("UIRouter Module Root Options");
-export const UIROUTER_CHILD_MODULE = new OpaqueToken("UIRouter Module Options");
+export const UIROUTER_ROOT_MODULE = new OpaqueToken("UIRouter Root Module");
+export const UIROUTER_MODULE_TOKEN = new OpaqueToken("UIRouter Module");
 

src/resolve/resolveContext.ts

@@ -2,7 +2,7 @@
 import { find, tail, uniqR, unnestR, inArray } from "../common/common";
 import {propEq} from "../common/hof";
 import {trace} from "../common/trace";
-import {services} from "../common/coreservices";
+import {services, $InjectorLike} from "../common/coreservices";
 import {resolvePolicies, PolicyWhen} from "./interface";
 
 import {PathNode} from "../path/node";
@@ -13,10 +13,12 @@ import {stringify} from "../common/strings";
 import {Transition} from "../transition/transition";
 import {UIInjector} from "../common/interface";
 
-var when = resolvePolicies.when;
+const when = resolvePolicies.when;
 const ALL_WHENS = [when.EAGER, when.LAZY];
 const EAGER_WHENS = [when.EAGER];
 
+export const NATIVE_INJECTOR_TOKEN = "Native Injector";
+
 /**
  * Encapsulates Depenency Injection for a path of nodes
  *
@@ -28,6 +30,7 @@ const EAGER_WHENS = [when.EAGER];
  * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.
  */
 export class ResolveContext {
+ _injector: UIInjector;
 
  constructor(private _path: PathNode[]) { }
 
@@ -131,7 +134,7 @@ export class ResolveContext {
  }
 
  injector(): UIInjector {
- return new UIInjectorImpl(this);
+ return this._injector || (this._injector = new UIInjectorImpl(this));
  }
 
  findNode(resolvable: Resolvable): PathNode {
@@ -147,16 +150,16 @@ export class ResolveContext {
  let node = this.findNode(resolvable);
  // Find which other resolvables are "visible" to the `resolvable` argument
  // subpath stopping at resolvable's node, or the whole path (if the resolvable isn't in the path)
- var subPath: PathNode[] = PathFactory.subPath(this._path, x => x === node) || this._path;
- var availableResolvables: Resolvable[] = subPath
+ let subPath: PathNode[] = PathFactory.subPath(this._path, x => x === node) || this._path;
+ let availableResolvables: Resolvable[] = subPath
  .reduce((acc, node) => acc.concat(node.resolvables), []) //all of subpath's resolvables
  .filter(res => res !== resolvable); // filter out the `resolvable` argument
 
  const getDependency = (token: any) => {
  let matching = availableResolvables.filter(r => r.token === token);
  if (matching.length) return tail(matching);
 
- let fromInjector = services.$injector.get(token);
+ let fromInjector = this.injector().get(token);
  if (!fromInjector) {
  throw new Error("Could not find Dependency Injection token: " + stringify(token));
  }
@@ -169,7 +172,12 @@ export class ResolveContext {
 }
 
 class UIInjectorImpl implements UIInjector {
- constructor(public context: ResolveContext) { }
+ native: $InjectorLike;
+
+ constructor(public context: ResolveContext) {
+ this.native = this.get(NATIVE_INJECTOR_TOKEN) || services.$injector;
+ }
+
  get(token: any) {
  var resolvable = this.context.getResolvable(token);
  if (resolvable) {
@@ -178,15 +186,12 @@ class UIInjectorImpl implements UIInjector {
  }
  return resolvable.data;
  }
- return services.$injector.get(token);
+ return this.native && this.native.get(token);
  }
 
  getAsync(token: any) {
  var resolvable = this.context.getResolvable(token);
  if (resolvable) return resolvable.get(this.context);
- return services.$q.when(services.$injector.get(token));
+ return services.$q.when(this.native.get(token));
  }
-
- /** The native injector ($injector on ng1, Root Injector on ng2, justjs injector for everything else) */
- native = services.$injector;
 }