injection-js

constructor

constructor(desc: string);

method toString

toString: () => string;

property NULL

static NULL: Injector;

property THROW_IF_NOT_FOUND

static THROW_IF_NOT_FOUND: Object;

method get

abstract get: {
    <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T): T;
    (token: any, notFoundValue?: any): any;
};

• Retrieves an instance from the injector based on the provided token. If not found: - Throws NoProviderError if no notFoundValue that is not equal to Injector.THROW_IF_NOT_FOUND is given - Returns the notFoundValue otherwise

• Deprecated

  from v4.0.0 use Type or InjectionToken {duplicate}

constructor

constructor(_desc: string);

method toString

toString: () => string;

property parent

readonly parent: Injector;

• Parent of this injector.

  <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection. -->

  ### Example ([live demo](http://plnkr.co/edit/eosMGo?p=preview))

  var parent = ReflectiveInjector.resolveAndCreate([]);
  var child = parent.resolveAndCreateChild([]);
  expect(child.parent).toBe(parent);

method createChildFromResolved

abstract createChildFromResolved: (
    providers: ResolvedReflectiveProvider[]
) => ReflectiveInjector;

• Creates a child injector from previously resolved providers.

  <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection. -->

  This API is the recommended way to construct injectors in performance-sensitive parts.

  ### Example ([live demo](http://plnkr.co/edit/VhyfjN?p=preview))

  class ParentProvider {}
  class ChildProvider {}
  
  var parentProviders = ReflectiveInjector.resolve([ParentProvider]);
  var childProviders = ReflectiveInjector.resolve([ChildProvider]);
  
  var parent = ReflectiveInjector.fromResolvedProviders(parentProviders);
  var child = parent.createChildFromResolved(childProviders);
  
  expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
  expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
  expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));

method fromResolvedProviders

static fromResolvedProviders: (
    providers: ResolvedReflectiveProvider[],
    parent?: Injector
) => ReflectiveInjector;

• Creates an injector from previously resolved providers.

  This API is the recommended way to construct injectors in performance-sensitive parts.

  ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))

  @Injectable()
  class Engine {
  }
  
  @Injectable()
  class Car {
    constructor(public engine:Engine) {}
  }
  
  var providers = ReflectiveInjector.resolve([Car, Engine]);
  var injector = ReflectiveInjector.fromResolvedProviders(providers);
  expect(injector.get(Car) instanceof Car).toBe(true);

  Modifiers

  • @experimental

method get

abstract get: (token: any, notFoundValue?: any) => any;

method instantiateResolved

abstract instantiateResolved: (provider: ResolvedReflectiveProvider) => any;

• Instantiates an object using a resolved provider in the context of the injector.

  The created object does not get cached by the injector.

  ### Example ([live demo](http://plnkr.co/edit/ptCImQ?p=preview))

  @Injectable()
  class Engine {
  }
  
  @Injectable()
  class Car {
    constructor(public engine:Engine) {}
  }
  
  var injector = ReflectiveInjector.resolveAndCreate([Engine]);
  var carProvider = ReflectiveInjector.resolve([Car])[0];
  var car = injector.instantiateResolved(carProvider);
  expect(car.engine).toBe(injector.get(Engine));
  expect(car).not.toBe(injector.instantiateResolved(carProvider));

method resolve

static resolve: (providers: Provider[]) => ResolvedReflectiveProvider[];

• Turns an array of provider definitions into an array of resolved providers.

  A resolution is a process of flattening multiple nested arrays and converting individual providers into an array of ResolvedReflectiveProviders.

  ### Example ([live demo](http://plnkr.co/edit/AiXTHi?p=preview))

  @Injectable()
  class Engine {
  }
  
  @Injectable()
  class Car {
    constructor(public engine:Engine) {}
  }
  
  var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
  
  expect(providers.length).toEqual(2);
  
  expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
  expect(providers[0].key.displayName).toBe("Car");
  expect(providers[0].dependencies.length).toEqual(1);
  expect(providers[0].factory).toBeDefined();
  
  expect(providers[1].key.displayName).toBe("Engine");
  });

  See ReflectiveInjector#fromResolvedProviders for more info.

method resolveAndCreate

static resolveAndCreate: (
    providers: Provider[],
    parent?: Injector
) => ReflectiveInjector;

• Resolves an array of providers and creates an injector from those providers.

  The passed-in providers can be an array of Type, Provider, or a recursive array of more providers.

  ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))

  @Injectable()
  class Engine {
  }
  
  @Injectable()
  class Car {
    constructor(public engine:Engine) {}
  }
  
  var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
  expect(injector.get(Car) instanceof Car).toBe(true);

  This function is slower than the corresponding fromResolvedProviders because it needs to resolve the passed-in providers first. See Injector#resolve and Injector#fromResolvedProviders.

method resolveAndCreateChild

abstract resolveAndCreateChild: (providers: Provider[]) => ReflectiveInjector;

• Resolves an array of providers and creates a child injector from those providers.

  <!-- TODO: Add a link to the section of the user guide talking about hierarchical injection. -->

  The passed-in providers can be an array of Type, Provider, or a recursive array of more providers.

  ### Example ([live demo](http://plnkr.co/edit/opB3T4?p=preview))

  class ParentProvider {}
  class ChildProvider {}
  
  var parent = ReflectiveInjector.resolveAndCreate([ParentProvider]);
  var child = parent.resolveAndCreateChild([ChildProvider]);
  
  expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
  expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
  expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));

  This function is slower than the corresponding createChildFromResolved because it needs to resolve the passed-in providers first. See Injector#resolve and Injector#createChildFromResolved.

method resolveAndInstantiate

abstract resolveAndInstantiate: (provider: Provider) => any;

• Resolves a provider and instantiates an object in the context of the injector.

  The created object does not get cached by the injector.

  ### Example ([live demo](http://plnkr.co/edit/yvVXoB?p=preview))

  @Injectable()
  class Engine {
  }
  
  @Injectable()
  class Car {
    constructor(public engine:Engine) {}
  }
  
  var injector = ReflectiveInjector.resolveAndCreate([Engine]);
  
  var car = injector.resolveAndInstantiate(Car);
  expect(car.engine).toBe(injector.get(Engine));
  expect(car).not.toBe(injector.resolveAndInstantiate(Car));

constructor

constructor(token: Object, id: number);

• Private

property displayName

readonly displayName: string;

• Returns a stringified token.

property id

id: number;

property numberOfKeys

static readonly numberOfKeys: number;

• Returns

  the number of keys registered in the system.

property token

token: Object;

method get

static get: (token: Object) => ReflectiveKey;

• Retrieves a Key for a token.

constructor

constructor(factory: Function, dependencies: ReflectiveDependency[]);

property dependencies

dependencies: ReflectiveDependency[];

• Arguments (dependencies) to the factory function.

property factory

factory: Function;

• Factory function which can return an instance of an object represented by a key.

property multi

multi?: boolean;

• If true, then injector returns an array of instances. This is useful to allow multiple providers spread across many files to provide configuration information to a common token.

  ### Example

property provide

provide: any;

• An injection token. (Typically an instance of Type or InjectionToken, but can be any).

property useClass

useClass: Type<any>;

• Class to instantiate for the token.

property multi

multi?: boolean;

• If true, then injector returns an array of instances. This is useful to allow multiple providers spread across many files to provide configuration information to a common token.

  ### Example

property provide

provide: any;

• An injection token. (Typically an instance of Type or InjectionToken, but can be any).

property useExisting

useExisting: any;

• Existing token to return. (equivalent to injector.get(useExisting))

property deps

deps?: any[];

• A list of tokens which need to be resolved by the injector. The list of values is then used as arguments to the useFactory function.

property multi

multi?: boolean;

• If true, then injector returns an array of instances. This is useful to allow multiple providers spread across many files to provide configuration information to a common token.

  ### Example

property provide

provide: any;

• An injection token. (Typically an instance of Type or InjectionToken, but can be any).

property useFactory

useFactory: Function;

• A function to invoke to create a value for this token. The function is invoked with resolved values of tokens in the deps field.

call signature

(): any;

construct signature

new (): Host;

call signature

(): any;

• Specifies that an injector should retrieve a dependency from any injector until reaching the host element of the current component.

  @Injectable()
  class Car {
    constructor(@Host() public engine:Engine) {}
  }

  For more details, see the .

  ### Example

property token

token: any;

construct signature

new (): Injectable;

call signature

(): any;

• A marker metadata that marks a class as available to Injector for creation.

  @Injectable()
  class Car {}

  For more details, see the .

  ### Example

  Injector will throw NoAnnotationError when trying to instantiate a class that does not have @Injectable marker, as shown in the example below.

construct signature

new (token: any): Inject;

call signature

(token: any): any;

• A parameter decorator that specifies a dependency.

  @Injectable()
  class Car {
    constructor(@Inject("MyEngine") public engine:Engine) {}
  }

  For more details, see the .

  ### Example

  When @Inject() is not present, Injector will use the type annotation of the parameter.

  ### Example

construct signature

new (): Optional;

call signature

(): any;

• A parameter metadata that marks a dependency as optional. Injector provides null if the dependency is not found.

  @Injectable()
  class Car {
    constructor(@Optional() public engine:Engine) {}
  }

  For more details, see the .

  ### Example

property key

key: ReflectiveKey;

• A key, usually a Type<any>.

property multiProvider

multiProvider: boolean;

• Indicates if the provider is a multi-provider or a regular provider.

property resolvedFactories

resolvedFactories: ResolvedReflectiveFactory[];

• Factory function which can return an instance of an object represented by a key.

construct signature

new (): Self;

call signature

(): any;

• Specifies that an Injector should retrieve a dependency only from itself.

  @Injectable()
  class Car {
    constructor(@Self() public engine:Engine) {}
  }

  For more details, see the .

  ### Example

construct signature

new (): SkipSelf;

call signature

(): any;

• Specifies that the dependency resolution should start from the parent injector.

  @Injectable()
  class Car {
    constructor(@SkipSelf() public engine:Engine) {}
  }

  For more details, see the .

  ### Example

construct signature

new (...args: any[]): T;

property annotations

annotations: any[];

• Storage for the accumulated annotations so far used by the DSL syntax.

  Used by Class to annotate the generated class.

method Class

Class: (obj: ClassDefinition) => Type<any>;

• Generate a class from the definition and annotate it with TypeDecorator#annotations.

call signature

<T extends Type<any>>(type: T): T;

• Invoke as ES7 decorator.

call signature

(target: object, propertyKey?: string | symbol, parameterIndex?: number): void;

property multi

multi?: boolean;

• If true, then injector returns an array of instances. This is useful to allow multiple providers spread across many files to provide configuration information to a common token.

  ### Example

property provide

provide: any;

• An injection token. (Typically an instance of Type or InjectionToken, but can be any).

property useValue

useValue: any;

• The value to inject.