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 0f34d1289a generated from tag 0.0.8 1 month ago
classes generated from tag 0.0.6 1 month ago
interfaces generated from tag 0.0.6 1 month ago
LICENSE.md generated from tag 0.0.6 1 month ago
README.md generated from tag 0.0.8 1 month ago
globals.md generated from tag 0.0.6 1 month ago

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

Version

0.0.8

Classes

Interfaces

Type aliases

Variables

Functions

Type aliases

Constructor

Ƭ Constructor: Function & object


GenericClassDecorator

Ƭ GenericClassDecorator: function

Generic ClassDecorator type

Type declaration:

▸ (target: T): void

Parameters:

Name Type
target T

SingletonDefinition

Ƭ SingletonDefinition: object

Type declaration:

  • ctor: Type‹any›

  • initializationPriority? : undefined | number

Variables

Const Injector

Injector: _Injector‹› = new _Injector()

The Injector stores services and resolves requested instances.

Functions

Const ERR_NO_INITIALIZE_WITH_PRIORITY

ERR_NO_INITIALIZE_WITH_PRIORITY(ctor: Constructor‹any›): string

Parameters:

Name Type
ctor Constructor‹any›

Returns: string


Const ERR_NO_INJECTION_TOKEN

ERR_NO_INJECTION_TOKEN(ctor: Constructor‹any›): string

Parameters:

Name Type
ctor Constructor‹any›

Returns: string


Inject

Inject(token: Constructor‹any›): (Anonymous function)

Parameters:

Name Type
token Constructor‹any›

Returns: (Anonymous function)


Singleton

Singleton(config?: undefined | object): GenericClassDecoratorType‹any››

constructor

Parameters:

Name Type
config? undefined | object

Returns: GenericClassDecoratorType‹any››