di-container-js v1.0.0
DI container
Dependency injection library for js with zero dependencies
Basic usage
import DiContainer from "di-container-js";
// OR
const DiContainer = require("di-container-js").DiContainer;
let diContainer = new DiContainer();
const componentRef1 = Symbol(),
componentRef2 = "component2";
class Component2 {
// define `static dependencies()` method in your class to specify what dependencies are needed
// otherwise required dependecies will be resolved from constructor arguments
static dependencies() {
return [componentRef1];
}
constructor(component1) {
this.component1 = component1;
}
}
class Component1 {
constructor() {
}
}
diContainer.registerClass(componentRef1, Component1);
diContainer.registerClass(componentRef2, Component2);
(async () => {
// .get method returns promise resolved to dependency instance
let component2Instance = await diContainer.get(componentRef2);
// now component2Instance has component1 assigned to it
})();
You can also inject diContainer itself to any component:
constructor(diContainer, ...) {
this.diContainer = diContainer;
...
}
Providing configuration
...
class TestClass {
constructor() {
}
postConstruct(config) {
// gets called by DI container after instance created
// can return promise, in this case DI container will
// wait until promise resolved
return Promise.resolved();
}
}
let diContainer = new DiContainer();
// pass configuration as third parameter to .registerClass
diContainer.registerClass("testDependency", TestClass, {configKey: "configValue"});
// OR
// provide config using .configure method
diContainer.configure("testDependency", {configKey: "configValue"});
(async () => {
let testDependency = await diContainer.get("testDependency");
// do something
})();
Usage with React
To use dependency injection with React class components
you should have a custom ComponentProvider.
Unlike default one, it should construct a react component instead of an instance of a class.
There is a useful example
of inject()
decorator function which uses the custom component provider ReactProvider
and InjectionHoc
high-order component to add dependency injection functionality to React class components. Usage:
import {inject} from '../../di/inject';
class MyComponent extends React.Component {
static dependencies() {
return [/*...*/];
}
}
export default inject(MyComponent);
API Reference
DiContainer
register(componentRef, componentProvider)
Register a dependency using the ComponentProvider
Param | Type | Description |
---|---|---|
componentRef | symbol | string | dependency identifier |
componentProvider | ComponentProvider | provider which is used to construct a dependency instance |
registerClass(componentRef, classRef, config)
Register a dependency using a class reference
Param | Type | Description |
---|---|---|
componentRef | symbol | string | dependency identifier |
classRef | function | reference to a class |
config | object | configuration object which is passed to the postConstruct method of a class after |
it's creation |
provide(componentRef, instance)
Provide a component instance
Param | Type |
---|---|
componentRef | symbol | string |
instance | any |
configure(componentRef, config, mergeConfig)
Sets a configuration object which will be passed to 'postConstruct' method of a component
Param | Type | Default | Description |
---|---|---|---|
componentRef | symbol | string | ||
config | object | ||
mergeConfig | boolean | true | whenever merge new config to old one |
get(componentRef) ⇒ Promise.<any>
Retrieve a component instance
Param | Type |
---|---|
componentRef | symbol | string |
constructExternal(classRef, config) ⇒ Promise.<(*|undefined)>
Construct an instance of a class without registration in the DI container
Param | Type |
---|---|
classRef | function |
config | object |
constructExternalUsingProvider(provider) ⇒ Promise.<(*|undefined)>
Construct a component without registration in the DI container
Param | Type |
---|---|
provider | ComponentProvider |
createFactory(classRef) ⇒ Promise.<ComponentFactory>
A factory itself is not registered in DI container class and inject dependencies to them.
Param | Type |
---|---|
classRef | function |
isInitialized(componentRef) ⇒ boolean
Param | Type |
---|---|
componentRef | symbol | string |
isProvided(componentRef) ⇒ boolean
Param | Type |
---|---|
componentRef | symbol | string |
3 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago
4 years ago