+
+
+
+
\ No newline at end of file
diff --git a/gulpfile.js b/gulpfile.js
index 10c029c7..f10b3f06 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -28,7 +28,7 @@ gulp.task("lint", function() {
return gulp.src([
"src/**/**.ts",
"test/**/**.test.ts",
- "type_definitions/**/**.ts"
+ "type_definitions/inversify/*.ts"
])
.pipe(tslint())
.pipe(tslint.report("verbose", config));
@@ -87,7 +87,11 @@ gulp.task("build", function(cb) {
//******************************************************************************
gulp.task("document", function () {
return gulp
- .src(["src/*.ts"])
+ .src([
+ "src/**/**.ts",
+ "typings/browser.d.ts",
+ "node_modules/reflect-metadata/reflect-metadata.d.ts"
+ ])
.pipe(typedoc({
// TypeScript options (see typescript docs)
target: "es5",
@@ -102,9 +106,10 @@ gulp.task("document", function () {
preserveConstEnums: true,
suppressImplicitAnyIndexErrors: true,
// Output options (see typedoc docs)
- out: "./documentation",
+ out: "./docs",
name: "InversifyJS",
- version: true
+ version: true,
+ theme: "minimal"
}));
});
diff --git a/package.json b/package.json
index 6faea28a..f1f0118f 100644
--- a/package.json
+++ b/package.json
@@ -1,9 +1,8 @@
{
"name": "inversify",
- "version": "2.0.0-alpha.2",
+ "version": "2.0.0-alpha.3",
"description": "A lightweight IoC container written in TypeScript.",
"main": "dist/inversify.js",
- "typings": "type_definitions/inversify-npm.d.ts",
"directories": {
"test": "test"
},
diff --git a/src/activation/decorator_utils.ts b/src/activation/decorator_utils.ts
index 38c57f9a..8e84564f 100644
--- a/src/activation/decorator_utils.ts
+++ b/src/activation/decorator_utils.ts
@@ -46,10 +46,10 @@ function _param(paramIndex, decorator) {
}
// Allows VanillaJS developers to use decorators:
-// decorate(Inject("IFoo", "IBar"), FooBar);
-// decorate(ParamNames("foo", "bar"), FooBar);
-// decorate(Named("foo"), FooBar, 0);
-// decorate(Tagged("bar"), FooBar, 1);
+// decorate(inject("IFoo", "IBar"), FooBar);
+// decorate(paramNames("foo", "bar"), FooBar);
+// decorate(named("foo"), FooBar, 0);
+// decorate(tagged("bar"), FooBar, 1);
function decorate(
decorator: (ClassDecorator|ParameterDecorator),
target: any,
diff --git a/src/activation/inject.ts b/src/activation/inject.ts
index 47568d7f..52f6e561 100644
--- a/src/activation/inject.ts
+++ b/src/activation/inject.ts
@@ -3,7 +3,7 @@
import * as METADATA_KEY from "../constants/metadata_keys";
import * as ERRORS_MSGS from "../constants/error_msgs";
-function Inject(...paramTypes: string[]) {
+function inject(...paramTypes: string[]) {
return function(target: any) {
if (Reflect.hasOwnMetadata(METADATA_KEY.INJECT, target) === true) {
@@ -16,4 +16,4 @@ function Inject(...paramTypes: string[]) {
};
}
-export default Inject;
+export default inject;
diff --git a/src/activation/named.ts b/src/activation/named.ts
index ae4a9b4c..fe45b21f 100644
--- a/src/activation/named.ts
+++ b/src/activation/named.ts
@@ -4,11 +4,11 @@ import Metadata from "../activation/metadata";
import { tagParameter } from "./decorator_utils";
// Used to add named metadata which is used to resolve name-based contextual bindings.
-function Named(name: string) {
+function named(name: string) {
return function(target: any, targetKey: string, index: number) {
let metadata = new Metadata("named", name);
return tagParameter(target, targetKey, index, metadata);
};
}
-export default Named;
+export default named;
diff --git a/src/activation/paramnames.ts b/src/activation/paramnames.ts
index 44f201db..7402d3e8 100644
--- a/src/activation/paramnames.ts
+++ b/src/activation/paramnames.ts
@@ -3,17 +3,17 @@
import * as METADATA_KEY from "../constants/metadata_keys";
import * as ERRORS_MSGS from "../constants/error_msgs";
-function ParamNames(...paramNames: string[]) {
+function paramNames(...names: string[]) {
return function(target: any) {
if (Reflect.hasOwnMetadata(METADATA_KEY.PARAM_NAMES, target) === true) {
throw new Error(ERRORS_MSGS.DUPLICATED_PARAM_NAMES_DECORATOR);
}
- Reflect.defineMetadata(METADATA_KEY.PARAM_NAMES, paramNames, target);
+ Reflect.defineMetadata(METADATA_KEY.PARAM_NAMES, names, target);
return target;
};
}
-export default ParamNames;
+export default paramNames;
diff --git a/src/activation/tagged.ts b/src/activation/tagged.ts
index 10e3cd8a..ff9ab759 100644
--- a/src/activation/tagged.ts
+++ b/src/activation/tagged.ts
@@ -4,11 +4,11 @@ import Metadata from "../activation/metadata";
import { tagParameter } from "./decorator_utils";
// Used to add custom metadata which is used to resolve metadata-based contextual bindings.
-function Tagged(metadataKey: string, metadataValue: any) {
+function tagged(metadataKey: string, metadataValue: any) {
return function(target: any, targetKey: string, index: number) {
let metadata = new Metadata(metadataKey, metadataValue);
return tagParameter(target, targetKey, index, metadata);
};
}
-export default Tagged;
+export default tagged;
diff --git a/src/bindings/binding.ts b/src/bindings/binding.ts
index 0dc4a8a7..b6ea507a 100644
--- a/src/bindings/binding.ts
+++ b/src/bindings/binding.ts
@@ -33,13 +33,22 @@ class Binding
+
+
+
+
+
+
+
+ "activation/decorator_
+
+
+
+
+
+
+
+
+
+
+
+
+
+ tag
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ param
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ implementation
+
+
+
+
+
+
+
+
+ proxy
+
+
+
+
+
+ runtime
+
+
+
+
+
+
+
+
+
+
+
+
+
+ "bindings/binding_
+
+
+
+
+ Binding
+
+
+
+
+ Multiple
+
+
+
+
+
+ No
+
+
+
+
+
+ Only
+
+
+
+
+
+
+
+ "bindings/binding_
+
+
+
+
+ Binding
+
+
+
+
+
+
+
+
+
+
+
+
+ "bindings/binding_
+
+
+
+
+ Binding
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ "constants/error_
+
+
+
+
+ AMBIGUOUS_
+
+
+
+
+
+ CANNOT_
+
+
+
+
+
+ CIRCULAR_
+
+
+
+
+
+ DUPLICATED_
+
+
+
+
+
+ DUPLICATED_
+
+
+
+
+
+ INVALID_
+
+
+
+
+
+ KEY_
+
+
+
+
+
+ NOT_
+
+
+
+
+
+ NOT_
+
+
+
+
+
+ NULL_
+
+
+
+
+
+
+ "constants/metadata_
+
+
+
+
+
+
+
+ PARAM_
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ _binding
+
+
+
+
+
+
+
+
+
+
+
+ _plan
+
+
+
+
+
+
+
+
+
+ get
+
+
+
+
+
+
+ unbind
+
+
+
+
+
+ "kernel/key_
+
+
+
+
+ Key
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ get
+
+
+
+ has
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ add
+
+
+
+
+
+
+
+
+
+
+
+
+ parent
+
+
+
+
+
+ root
+
+
+
+
+
+
+
+
+
+
+
+ _create
+
+
+
+ _get
+
+
+
+ _throw
+
+
+
+ create
+
+
+
+ create
+
+
+
+ get
+
+
+
+
+
+ "planning/queryable_
+
+
+
+
+ Queryable
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ends
+
+
+
+
+
+
+ starts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ child
+
+
+
+
+
+
+
+
+ parent
+
+
+
+
+
+ parent
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ add
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ is
+
+
+
+ is
+
+
+
+ is
+
+
+
+ matches
+
+
+
+ matches
+
+
+
+
+
+
+
+
+
+
+
+
+ _middle
+
+
+
+
+
+ _create
+
+
+
+
+
+
+
+
+
+
+
+ "syntax/binding_
+
+
+
+
+ Binding
+
+
+
+
+
+
+
+
+
+
+ in
+
+
+
+ in
+
+
+
+
+
+
+
+
+
+
+
+ "syntax/binding_
+
+
+
+
+ Binding
+
+
+
+
+
+
+
+
+
+
+
+
+
+ to
+
+
+
+ to
+
+
+
+ to
+
+
+
+ to
+
+
+
+
+
+
+
+
+
+ InversifyJS
+
+ 
+ 
+ 
+ 
+ 
+ 
A lightweight IoC container written in TypeScript. + Visit http://inversify.io/ for more information.
+About
+InversifyJS is a lightweight (4KB) pico inversion of control (IoC) container for TypeScript and JavaScript apps. A pico IoC container uses a class constructor to identify and inject its dependencies.
+InversifyJS is easy to integrate with the majority of existing JavaScript frameworks and encourage the usage of the best OOP and IoC practices.
+Motivation
+JavaScript applications are becoming larger and larger day after day. As a result we are using a lot of our architecture experience from languages like Java or C# in JavaScript. We are embracing OOP with JavaScript but we are not writing SOLID JavaScript. InversifyJS has been designed to allow JavaScript developers to write code that adheres to the SOLID principles.
+Philosophy
+InversifyJS has been developed with 3 main goals:
+-
+
Allow JavaScript developers to write code that adheres to the SOLID principles.
+
+ Facilitate and encourage the adherence to the best OOP and IoC practices.
+
+ Add as little runtime overhead as possible.
+
+
Installation
+You can get the latest release and the type definitions using npm.
+npm install inversify --save
+Note: We have decided to drop support for bower and tsd. The InversifyJS type definitions are included in the npm package as it is recommended by the TypeScript development team.
+If you are planing to use inversify as a global you will need to add a reference to the file named inversify-global.d.ts this file is included in the npm package:
/// <reference path="./node_modules/inversify/type_definitions/inversify-global.d.ts" />
+The Basics (with TypeScript)
+The main goal of InversifyJS is top allow JavaScript developers to write code that adheres to the SOLID principles. + Many of these principles refer to the usage of interfaces. + The main reason why it is not possible to write native SOLID JavaScript is because the language lacks interfaces. + In the other hand, TypeScript features interfaces, so, if you are going to use InversifyJS it is recommended + to work with TypeScript to get the most out of it.
+1. Declare interfaces & implementations
+Our goal is to write SOLID code. This means that we should "depend upon Abstractions. Do not depend upon concretions." + so we will start by declaring some interfaces (abstractions).
+interface INinja {
+ fight(): string;
+ sneak(): string;
+}
+
+interface IKatana {
+ hit(): string;
+}
+
+interface IShuriken {
+ throw();
+}
+We can continue declaring some classes which implement them (concretions).
+ We will start by declaring two classes (Katana & Shuriken) which don't have any dependencies.
class Katana implements IKatana {
+ public hit() {
+ return "cut!";
+ }
+}
+
+class Shuriken implements IShuriken {
+ public throw() {
+ return "hit!";
+ }
+}
+Now we are going to declare a class named Ninja, which has two dependencies (IKatana & IShuriken):
@Inject("IKatana", "IShuriken")
+class Ninja implements INinja {
+
+ private _katana: IKatana;
+ private _shuriken: IShuriken;
+
+ public constructor(katana: IKatana, shuriken: IShuriken) {
+ this._katana = katana;
+ this._shuriken = shuriken;
+ }
+
+ public fight() { return this._katana.hit(); };
+ public sneak() { return this._shuriken.throw(); };
+
+}
+2. Bind interfaces to implementations
+Before we can start resolving and injecting dependencies we need to create an instance of the InversifyJS Kernel class.
+ The Kernel will automatically detect is a class has some dependencies by examining the @Inject annotation.
+ The Kernel will automatically detect if a class has some dependencies by examining the metadata provided by the Inject decorator.
import { Kernel } from "inversify";
+var kernel = new Kernel();
+In order to resolve a dependency, the kernel needs to be told which implementation type (classes) to associate with each service type (interfaces). + We will use type bindings for this purpose. A type binding (or just a binding) is a mapping between a service type (an interface), and an implementation type (class).
+kernel.bind<INinja>("INinja").to(Ninja);
+ kernel.bind<IKatana>("IKatana").to(Katana);
+ kernel.bind<IShuriken>("IShuriken").to(Shuriken).inSingletonScope();
+When we declare a type binding, the TypeScript compiler will check that the implementation type (class) is actually and implementation of the service type (interface) and throw a compilation error if that is not the case.
+// Compilation error: Shuriken is not assignable to type IKatana
+kernel.bind<IKatana>("IKatana").to(Shuriken);
+We should keep the InversifyJS Kernel instantiation and type bindings centralized in one unique IoC configuration file. + This will help us to abstract our application from the IoC configuration.
+3. Resolve & inject dependencies
+After declaring the type bindings, we can invoke the kernel resolve method to resolve a dependency. + We will use a string as the interface identifier (instead of the interface itself) because the TypeScript interfaces are not available at runtime.
+let ninja = kernel.get<INinja>("INinja");
+If the interface that we are trying to resolve is bind to a class that has some dependencies, InversifyJS will + resolve and inject them into a new instance via the class constructor.
+// Katana and Shuriken instances has been injected into a new Ninja instance via its constructor
+expect(ninja.fight()).eql("cut!"); // true
+expect(ninja.sneak()).eql("hit!"); // true
+Our application dependency tree should have one unique root element, known as the application composition root, which is the + only place where we should invoke the resolve method.
+Invoking resolve every time we need to inject something, as if it was a Service Locator is an anti-pattern. + If we are working with an MVC framework the composition root should be located in the application class, somewhere + along the routing logic or in a controller factory class. Please refer to the integration examples if you need additional help.
+Integration with popular frameworks
+InversifyJS was designed with many popular JavaScript frameworks in mind. As a result, it is really easy to integrate with existing JavaScript frameworks and examples of integration with many popular frameworks are available in the official examples repository.
+Good Practices
+Dependency Inversion (DI) isn't rocket science. We just need to try to avoid new and singleton except when there's a compelling reason to use them, such as a utility method that has no external dependencies, or a utility class that could not possibly have any purpose outside the framework (interop wrappers and dictionary keys are common examples of this).
+Many of the problems with IoC frameworks come up when developers are first learning how to use them, and instead of actually changing the way they handle dependencies and abstractions to fit the IoC model, instead try to manipulate the IoC container to meet the expectations of their old coding style, which would often involve high coupling and low cohesion.
+Use a Composition Root to avoid the Service Locator anti-pattern
+Our application dependency tree should have one unique root element (known as the application composition root) which is the only component where we should invoke the resolve method.
+Invoking resolve every time we need to inject something, as if it was a Service Locator is an anti-pattern. If we are working with an MVC framework the composition root should be located in the application class, somewhere along the routing logic or in a controller factory class.
+Avoid Constructor over-injection
+Constructor over-injection is a violation of the Single Responsibility Principle. Too many constructor arguments indicates too many dependencies; too many dependencies indicates that the class is trying to do too much. Usually this error correlates with other code smells, such as unusually long or ambiguous ("manager") class names.
+Avoid the injection of data, as opposed to behaviour
+Injection of data, as opposed to behaviour, is a subtype of the poltergeist anti-pattern, with the 'geist in this case being the container. If a class needs to be aware of the current date and time, you don't inject a DateTime, which is data; instead, you inject an abstraction over the system clock. This is not only correct for DI; it is absolutely essential for testability, so that you can test time-varying functions without needing to actually wait on them.
+Avoid declaring every life cycle as Singleton
+Declaring every life cycle as Singleton is, to me, a perfect example of cargo cult programming and to a lesser degree the colloquially-named "object cesspool". I've seen more singleton abuse than I care to remember, and very little of it involves DI.
+Avoid implementation-specific interface types
+Another common error is implementation-specific interface types done just to be able to register it in the container. This is in and of itself a violation of the Dependency Inversion Principle (just because it's an interface, does not mean it's truly abstract) and often also includes interface bloat which violates the Interface Segregation Principle.
+Avoid optional dependencies
+In other words, there is a constructor that accepts dependency injection, but also another constructor that uses a "default" implementation. This also violates the DIP and tends to lead to LSP violations as well, as developers, over time, start making assumptions around the default implementation, and/or start new-ing up instances using the default constructor.
+Support
+If you are experience any kind of issues we will be happy to help. You can report an issue using the issues page or the chat. You can also ask questions at Stack overflow using the inversifyjs tag.
If you want to share your thoughts with the development team or join us you will be able to do so using the official the mailing list. You can check out the development wiki and browse the documented source code to learn more about InversifyJS internals.
+License
+License under the MIT License (MIT)
+Copyright © 2015 Remo H. Jansen
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Index
+
+
+
+
+ External modules
+-
+
- "activation/decorator_
utils"
+ - "activation/inject" +
- "activation/metadata" +
- "activation/named" +
- "activation/paramnames" +
- "activation/tagged" +
- "bindings/binding" +
- "bindings/binding_
count"
+ - "bindings/binding_
scope"
+ - "bindings/binding_
type"
+ - "constants/error_
msgs"
+ - "constants/metadata_
keys"
+ - "inversify" +
- "kernel/kernel" +
- "kernel/key_
value_ pair"
+ - "kernel/lookup" +
- "planning/context" +
- "planning/plan" +
- "planning/planner" +
- "planning/queryable_
string"
+ - "planning/request" +
- "planning/target" +
- "resolution/resolver" +
- "syntax/binding_
in_ when_ proxy_ syntax"
+ - "syntax/binding_
to_ syntax"
+
External modules
+"activation/decorator_utils"
+
+
+ _decorate
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
decorators: any
+
+ -
+
target: any
+
+
Returns void
+
+ -
+
_param
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
paramIndex: any
+
+ -
+
decorator: any
+
+
Returns (Anonymous function)
+
+ -
+
decorate
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
decorator: function | function
+
+ -
+
target: any
+
+ -
+
Optional parameterIndex: number
+
+
Returns void
+
+ -
+
tagParameter
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
target: any
+
+ -
+
targetKey: string
+
+ -
+
index: number
+
+ -
+
metadata: IMetadata
+
+
Returns any
+
+ -
+
"activation/inject"
+ + +inject
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
Rest ...paramTypes: string[]
+
+
Returns (Anonymous function)
+
+ -
+
"activation/metadata"
+ + +Metadata
+ + +constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
key: string
+
+ -
+
value: any
+
+
Returns Metadata
+
+ -
+
key
+ + +value
+ + +"activation/named"
+ + +named
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
name: string
+
+
Returns (Anonymous function)
+
+ -
+
"activation/paramnames"
+ + +paramNames
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
Rest ...names: string[]
+
+
Returns (Anonymous function)
+
+ -
+
"activation/tagged"
+ + +tagged
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
metadataKey: string
+
+ -
+
metadataValue: any
+
+
Returns (Anonymous function)
+
+ -
+
"bindings/binding"
+ + +Binding
+ + +constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
runtimeIdentifier: string
+
+
Returns Binding
+
+ -
+
cache
+ + +constraint
+ + +
+
+ Type declaration
+-
+
-
+
-
+
+
-
+
-
+
Parameters
+-
+
-
+
request: IRequest
+
+
Returns boolean
+
+ -
+
+ -
+
factory
+ + +implementationType
+
+
+ provider
+ + +proxyMaker
+
+
+
+
+ Type declaration
+-
+
-
+
-
+
+
-
+
-
+
Parameters
+-
+
-
+
injectable: T
+
+
Returns T
+
+ -
+
+ -
+
runtimeIdentifier
+
+
+ scope
+ + +type
+ + +"bindings/binding_count"
+
+
+ BindingCount
+
+
+ MultipleBindingsAvailable
+
+
+ NoBindingsAvailable
+
+
+ OnlyOneBindingAvailable
+
+
+ "bindings/binding_scope"
+
+
+ BindingScope
+
+
+ Singleton
+ + +Transient
+ + +"bindings/binding_type"
+
+
+ BindingType
+
+
+ Constructor
+ + +Factory
+ + +Instance
+ + +Invalid
+ + +Provider
+ + +Value
+ + +"constants/error_msgs"
+
+
+ AMBIGUOUS_MATCH
+
+
+ CANNOT_UNBIND
+
+
+ CIRCULAR_DEPENDENCY
+
+
+ DUPLICATED_INJECT_DECORATOR
+
+
+ DUPLICATED_PARAM_NAMES_DECORATOR
+
+
+ INVALID_BINDING_TYPE
+
+
+ KEY_NOT_FOUND
+
+
+ NOT_IMPLEMENTED
+
+
+ NOT_REGISTERED
+
+
+ NULL_ARGUMENT
+
+
+ "constants/metadata_keys"
+
+
+ INJECT
+ + +PARAM_NAMES
+
+
+ TAGGED
+ + +"inversify"
+ + +"kernel/kernel"
+ + +Kernel
+ + +constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
Default value options: IKernelOptions = { middleware: [], modules: [] }
+
+
Returns Kernel
+
+ -
+
_bindingDictionary
+
+
+ _planner
+ + +_resolver
+ + +_planAndResolve
+ -
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
Service
+
+
Parameters
+-
+
-
+
binding: IBinding<Service>
+
+
Returns Service
+
+ -
+
bind
+-
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
T
+
+
Parameters
+-
+
-
+
runtimeIdentifier: string
+
+
Returns IBindingToSyntax<T>
+
+ -
+
get
+-
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
Service
+
+
Parameters
+-
+
-
+
runtimeIdentifier: string
+
+
Returns Service
+
+ -
+
getAll
+ -
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
Service
+
+
Parameters
+-
+
-
+
runtimeIdentifier: string
+
+
Returns Service[]
+
+ -
+
unbind
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
runtimeIdentifier: string
+
+
Returns void
+
+ -
+
unbindAll
+ -
+
+
-
+
-
+
+
Returns void
+
+
"kernel/key_value_pair"
+
+
+ KeyValuePair
+
+
+ constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
key: string
+
+ -
+
value: T
+
+
Returns KeyValuePair
+
+ -
+
key
+ + +value
+ + +"kernel/lookup"
+ + +Lookup
+ + +constructor
+-
+
+
-
+
-
+
+
Returns Lookup
+
+
_dictionary
+ + +add
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
key: string
+
+ -
+
value: T
+
+
Returns void
+
+ -
+
get
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
key: string
+
+
Returns Array<T>
+
+ -
+
getIndexByKey
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
key: string
+
+
Returns number
+
+ -
+
hasKey
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
key: string
+
+
Returns boolean
+
+ -
+
remove
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
key: string
+
+
Returns void
+
+ -
+
"planning/context"
+ + +Context
+ + +constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
kernel: IKernel
+
+
Returns Context
+
+ -
+
kernel
+ + +plan
+ + +addPlan
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
plan: IPlan
+
+
Returns void
+
+ -
+
"planning/plan"
+ + +Plan
+ + +constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
parentContext: IContext
+
+ -
+
rootRequest: IRequest
+
+
Returns Plan
+
+ -
+
parentContext
+
+
+ rootRequest
+
+
+ "planning/planner"
+ + +Planner
+ + +_createSubRequest
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
parentRequest: IRequest
+
+ -
+
target: ITarget
+
+
Returns void
+
+ -
+
_getDependencies
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
func: Function
+
+
Returns Target[]
+
+ -
+
_throwWhenCircularDependenciesFound
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
request: IRequest
+
+ -
+
Default value previousServices: string[] = []
+
+
Returns void
+
+ -
+
createContext
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
kernel: IKernel
+
+
Returns IContext
+
+ -
+
createPlan
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
context: IContext
+
+ -
+
binding: IBinding<any>
+
+
Returns IPlan
+
+ -
+
getBindings
+ -
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
T
+
+
Parameters
+-
+
-
+
kernel: IKernel
+
+ -
+
service: string
+
+
Returns IBinding<T>[]
+
+ -
+
"planning/queryable_string"
+
+
+ QueryableString
+
+
+ constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
str: string
+
+
Returns QueryableString
+
+ -
+
str
+ + +contains
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
searchString: string
+
+
Returns boolean
+
+ -
+
endsWith
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
searchString: string
+
+
Returns boolean
+
+ -
+
equals
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
compareString: string
+
+
Returns boolean
+
+ -
+
startsWith
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
searchString: string
+
+
Returns boolean
+
+ -
+
value
+-
+
+
-
+
-
+
+
Returns string
+
+
"planning/request"
+ + +Request
+ + +constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
service: string
+
+ -
+
parentContext: IContext
+
+ -
+
parentRequest: IRequest
+
+ -
+
bindings: IBinding<any> | Array<IBinding<any>>
+
+ -
+
Default value target: ITarget = null
+
+
Returns Request
+
+ -
+
bindings
+ + +childRequests
+
+
+ guid
+ + +parentContext
+
+
+ parentRequest
+
+
+ service
+ + +target
+ + +_guid
+-
+
+
-
+
-
+
+
Returns string
+
+
_s4
+-
+
+
-
+
-
+
+
Returns string
+
+
addChildRequest
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
service: string
+
+ -
+
bindings: IBinding<any> | Array<IBinding<any>>
+
+ -
+
target: ITarget
+
+
Returns IRequest
+
+ -
+
"planning/target"
+ + +Target
+ + +constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
name: string
+
+ -
+
service: string
+
+ -
+
Optional namedOrTagged: string | IMetadata
+
+
Returns Target
+
+ -
+
metadata
+ + +name
+ + +service
+ + +isArray
+ -
+
+
-
+
-
+
+
Returns boolean
+
+
isNamed
+ -
+
+
-
+
-
+
+
Returns boolean
+
+
isTagged
+ -
+
+
-
+
-
+
+
Returns boolean
+
+
matchesName
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
name: string
+
+
Returns boolean
+
+ -
+
matchesTag
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
metadata: IMetadata
+
+
Returns boolean
+
+ -
+
"resolution/resolver"
+ + +Resolver
+ + +constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
Default value middleWare: IMiddleware[] = []
+
+
Returns Resolver
+
+ -
+
_middleWare
+
+
+ _createInstance
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
Func: object
+-
+
-
+
constructor: function
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
Rest ...args: any[]
+
+
Returns __type
+
+ -
+
+ -
+
+
+ -
+
-
+
injections: Object[]
+
+
Returns any
+
+ -
+
_inject
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
request: IRequest
+
+
Returns any
+
+ -
+
resolve
+-
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
Service
+
+
Parameters
+-
+
-
+
context: IContext
+
+
Returns Service
+
+ -
+
"syntax/binding_in_when_proxy_syntax"
+
+
+ BindingInWhenProxySyntax
+
+
+ constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
binding: IBinding<T>
+
+
Returns BindingInWhenProxySyntax
+
+ -
+
_binding
+ + +inSingletonScope
+ -
+
+
-
+
-
+
+
Returns IBindingInWhenProxySyntax<T>
+
+
inTransientScope
+ -
+
+
-
+
-
+
+
Returns IBindingInWhenProxySyntax<T>
+
+
proxy
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
proxymaker: function
+-
+
-
+
-
+
+
-
+
-
+
Parameters
+-
+
-
+
injectable: T
+
+
Returns T
+
+ -
+
+ -
+
+ -
+
Returns IBindingInWhenProxySyntax<T>
+
+ -
+
when
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
constraint: function
+-
+
-
+
-
+
+
-
+
-
+
Parameters
+-
+
-
+
request: IRequest
+
+
Returns boolean
+
+ -
+
+ -
+
+ -
+
Returns IBindingInWhenProxySyntax<T>
+
+ -
+
"syntax/binding_to_syntax"
+
+
+ BindingToSyntax
+
+
+ constructor
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
binding: IBinding<T>
+
+
Returns BindingToSyntax
+
+ -
+
_binding
+ + +to
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
constructor: object
+-
+
-
+
constructor: function
+-
+
+
-
+
-
+
+
Parameters
+-
+
-
+
Rest ...args: any[]
+
+
Returns __type
+
+ -
+
+ -
+
+
+ -
+
Returns IBindingInWhenProxySyntax<T>
+
+ -
+
toConstructor
+ -
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
T2
+
+
Parameters
+-
+
-
+
constructor: INewable<T2>
+
+
Returns IBindingInWhenProxySyntax<T>
+
+ -
+
toFactory
+ -
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
T2
+
+
Parameters
+-
+
-
+
factory: IFactoryCreator<T2>
+
+
Returns IBindingInWhenProxySyntax<T>
+
+ -
+
toProvider
+ -
+
+
-
+
-
+
+
Type parameters
+-
+
-
+
T2
+
+
Parameters
+-
+
-
+
provider: IProviderCreator<T2>
+
+
Returns IBindingInWhenProxySyntax<T>
+
+ -
+
toValue
+ -
+
+
-
+
-
+
+
Parameters
+-
+
-
+
value: T
+
+
Returns IBindingInWhenProxySyntax<T>
+
+ -
+
+
+ Generated using TypeDoc
+