nitowa 8b277c27ae 0.0.8 fix typo in readme | 2 years ago | |
---|---|---|
src | 2 years ago | |
test | 2 years ago | |
.drone.yml | 2 years ago | |
.gitignore | 2 years ago | |
Index.ts | 2 years ago | |
LICENSE.md | 2 years ago | |
README.md | 2 years ago | |
package-lock.json | 2 years ago | |
package.json | 2 years ago | |
tsconfig.json | 2 years ago |
depents is a typescript dependency injection framework
npm i depents
import {Singleton, Inject, Injector} from 'depents'
@Singleton()
class AClass{
private A = 'a'
getA () {
return this.A
}
}
@Singleton()
class BClass{
@Inject(AClass)
private a: AClass
getA(){
return this.a.getA()
}
}
console.log(Injector.resolve(BClass).getA()) //"a"
As interfaces are not a runtime construct in javascript, classes have to be used in their place in order to work with injection resolution.
Consider this quick example:
File MyModule/Interface.ts
export abstract class IComponent{
get: () => string
}
File MyModule/Implementation.ts
import {IComponent} from 'Interface.ts'
@Singleton({
interface: IComponentB,
})
export class ComponentB implements IComponent{
get(): string {
return "Hello!"
}
}
File Main.ts
import {IComponent} from 'MyModule/Interface.ts'
import {ComponentB} from 'Module/Implementation.ts'
ComponentB; //see Tree shaking pitfall below
Injector.resolve(IComponent).get()
TSC will attempt to exclude unused code in order to keep the compiled JS minimal. In the above example neither Main.ts
nor MyModule/Interface.ts
ever reference MyModule/Implementation.ts
and it is therefore considered unused code. This will lead to the compilation output not containing the ComponentB
class. To forcibly include ComponentB
, it has to be referenced at least once - even if it is a senseless operation like in the above example.
This version of depents will simply call all constructors of classes marked as Singleton
without arguments and it is therefore recommended that the user does not place initialization logic there. Alternatively, you may provide a function named initialize
which will be called during Singleton creation.
An example:
@Singleton()
export class Component{
private value: string
get(): string {
return this.value
}
initialize():void { //Called during object creation
this.value = "Hello!"
}
}
If your code requires objects to be initialized in a particular order, you may pass an optional initializationPriority
parameter to @Singleton
. The respective initialize operations will be called in order of initializationPriority
from lowest to highest. If omitted, the default value is 0.
@Singleton({
initializationPriority: 0
})
export class InitializedFirst{
private value: number
get(): number {
return this.value
}
initialize():void {
this.value = 1
}
}
@Singleton({
initializationPriority: 1
})
export class InitializedSecond{
@Inject(InitializedFirst)
private otherSingleton: InitializedFirst
private value: number
get(): number {
return this.value
}
initialize():void {
this.value = 1 + this.otherSingleton.get()
}
}
console.log(Injector.resolve(InitializedSecond).get()) //2