You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
nitowa 8b277c27ae 0.0.8 fix typo in readme hace 1 año
src 0.0.7 init order fix, add proper README hace 1 año
test 0.0.7 init order fix, add proper README hace 1 año
.drone.yml CI pls hace 1 año
.gitignore CI pls hace 1 año
Index.ts better code structure in injector/decorator and implemented initialization priorities hace 1 año
LICENSE.md Add LICENSE.md hace 1 año
README.md 0.0.8 fix typo in readme hace 1 año
package-lock.json CI pls hace 1 año
package.json 0.0.8 fix typo in readme hace 1 año
tsconfig.json init hace 1 año

README.md

Overview

Build Status Current Version Weekly Downloads License Type

depents is a typescript dependency injection framework

How to install

npm i depents

Quickstart (TL;DR)

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"

Working with interfaces as non-default injection tokens

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()

Tree shaking pitfall

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.

Initialization

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

Full documentation