feat(core): support AOT

BREAKING CHANGE: must specify provider dependencies

To migrate your code follow the example below:

Before:

providers: [
  ...ProvideOnce(MyService)
],

After:

providers: [
  ...ProvideOnce(MyService, [DependantService])
],

See the README for more details.

Author: adriancarriger

README.md

@@ -29,18 +29,41 @@ npm install angular-provide-once --save
 import { NgModule } from '@angular/core';
 import { ProvideOnce } from 'angular-provide-once';
 
+import { DependantService } from './dependant-service';
 import { MyService } from './my-service';
+import { OtherService } from './other-service';
 
 @NgModule({
   imports: [],
   providers: [
-    ...ProvideOnce(MyService)
+    OtherService,
+    DependantService,
+    ...ProvideOnce(MyService, [DependantService])
   ],
   declarations: []
 })
 export class MyModule { }
 ```
 
+## Api
+
+## `...ProvideOnce(targetService[, dependencyArray])`
+
+## Paramaters
+
+### targetService
+
+The service that should be provided once.
+
+### dependencyArray
+
+An optional array of services that the targetService depends on. Only include immediate dependencies (not dependencies of dependencies).
+
+## Return value
+
+`ProvideOnce` returns an array of Providers. Use the [spread operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator) (e.g. `...ProvideOnce`) to include it along with other services.
+
+
 ## License
 
 angular-provide-once is licensed under the MIT Open Source license. For more information, see the [LICENSE](LICENSE) file in this repository.

src/provide-once.ts

@@ -8,28 +8,27 @@ import {
   ValueProvider } from '@angular/core';
 import { reflector } from './private_import_core';
 
-export function ProvideOnce<T>(ProvidableType: Type<T>): Array<FactoryProvider | ValueProvider> {
-  return CreateProviders(new OpaqueToken('providable_type'), ProvidableType);
+export function ProvideOnce<T>(ProvidableType: Type<T>, params = []): Array<FactoryProvider | ValueProvider> {
+  return CreateProviders(new OpaqueToken('providable_type'), ProvidableType, params);
 }
 
 export function CreateProviders<T>(
   TOKEN: OpaqueToken,
-  ProvidableType: Type<T>): Array<FactoryProvider | ValueProvider> {
+  ProvidableType: Type<T>,
+  params): Array<FactoryProvider | ValueProvider> {
   return [
     {
       provide: TOKEN,
       useValue: ProvidableType
     },
     {
       provide: ProvidableType,
-      deps: [[new Optional(), new SkipSelf(), ProvidableType], TOKEN],
+      deps: [[new Optional(), new SkipSelf(), ProvidableType], TOKEN, ...params],
       useFactory: PROVIDER_FACTORY
     }
   ];
 }
 
-export function PROVIDER_FACTORY<T>(parentInstance: Type<T>, Token: Type<T>): Type<T> {
-  return parentInstance || ReflectiveInjector
-    .resolveAndCreate([Token, ...reflector.parameters(Token)])
-    .get(Token);
+export function PROVIDER_FACTORY<T>(parentInstance: Type<T>, Token: Type<T>, ...args): Type<T> {
+  return parentInstance || reflector.factory(Token).apply(this, [...args]);
 }

tests/provide-once.spec.ts

@@ -1,10 +1,38 @@
 /* tslint:disable:no-unused-variable */
 import { Injectable, ReflectiveInjector } from '@angular/core';
 import { async, inject, TestBed } from '@angular/core/testing';
+import { Observable, ReplaySubject, Subject } from 'rxjs/Rx';
 
 import { ProvideOnce } from '../src/provide-once';
 
+@Injectable()
+export class ClassA { }
+
+@Injectable()
+export class ClassB {
+  constructor(public classA: ClassA) { }
+}
+
+@Injectable()
+export class ClassC {
+  constructor(public classB: ClassB) { }
+}
+
 describe('Function: ProvideOnce', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        ClassA,
+        ...ProvideOnce(ClassB, [ClassA]),
+        ...ProvideOnce(ClassC, [ClassB])
+      ]
+    });
+  });
+
+  beforeEach(async(() => {
+    TestBed.compileComponents();
+  }));
+
   it('should create a provider', () => {
     const service = new ClassA();
     const providers: any = ProvideOnce(ClassA);
@@ -21,23 +49,21 @@ describe('Function: ProvideOnce', () => {
     expect(newService instanceof ClassA).toBe(true);
   });
 
-  it('should resolve dependencies in the provided factory function', () => {
+  it('should resolve dependencies in the provided factory function', inject([ClassB], (service: ClassB) => {
     const serviceA: ClassA = new ClassA();
     const serviceB: ClassB = new ClassB(serviceA);
-    const providers: any = ProvideOnce(ClassB);
-    const factory = providers[1].useFactory;
-    const newService: ClassB = factory(null, ClassB);
-    expect(newService instanceof ClassA).toBe(false);
-    expect(newService instanceof ClassB).toBe(true);
-    expect(serviceB.classA instanceof ClassA).toBe(true);
-    expect(newService.classA instanceof ClassA).toBe(true);
-  });
-});
+    expect(service instanceof ClassA).toBe(false);
+    expect(service instanceof ClassB).toBe(true);
+    expect(service.classA instanceof ClassA).toBe(true);
+  }));
 
-@Injectable()
-export class ClassA { }
-
-@Injectable()
-export class ClassB {
-  constructor(public classA: ClassA) { }
-}
+  it('should resolve dependencies in the provided factory function', inject([ClassC], (service: ClassC) => {
+    const serviceA: ClassA = new ClassA();
+    const serviceB: ClassB = new ClassB(serviceA);
+    const serviceC: ClassC = new ClassC(serviceB);
+    expect(service instanceof ClassB).toBe(false);
+    expect(service instanceof ClassC).toBe(true);
+    expect(serviceC.classB instanceof ClassB).toBe(true);
+    expect(service.classB.classA instanceof ClassA).toBe(true);
+  }));
+});