typedin
    TypeScript icon, indicating that this package has built-in type declarations

    1.0.0 • Public • Published

    typedin

    Simple yet powerful dependency injection library for TypeScript

    API Reference

    Installation

    With npm:

    npm install typedin --save
    

    Or just include lib/typedin.min.js and lib/typedin.d.ts to project.

    In tsconfig.json enable next options:

    "compilerOptions": {
    	"emitDecoratorMetadata": true,
    	"experimentalDecorators": true
    }
    

    Dependecies

    Library requires reflect-metadata polyfill.

    Simple usage

    1. Declare interface via abstract class and implement it (no typedin code yet).

       abstract class ILogService {
           log(message: string);
       }
       class ConsoleLogService extends ILogService {
           log(message: string) {
               console.info(message);
           }
       }
      
    2. Create and register a service. There we use Global, but there are variants (see below).

       import { Global } from "typedin";
      
       Global.register(ILogService, new ConsoleLogService());
      
    3. Declare property with decorator @inject to get service from container.

       import {inject} from "typedin";
      
       class SomeComponent {
           @inject logService: ILogService;
      
           foo() {
       	    this.logService.log("Hello there");
           }
       }
      

    Decorator @inject will determine type of property, resolve depenency container, and receive service from it.

    Providing dependency container

    In sample above we used Global container. Decorator @inject looks for the container in next order:

    1. In this object. You can implement interface 'IHaveContext' to provide context:

       import {inject, DiContainer IHaveContext} from "typedin";
      
       class SomeComponent implements IHaveContext {  
           @inject logService: ILogService;
      
           constructor(private context: DiContainer) {
           }        
           getDiContext() {
               return this.context;
           }
       }
      

    Another way (the same in internals), but without implementing IHaveContext. Just use setDiContext:

        import {inject, DiContainer, setDiContext} from "typedin";
    
        class SomeComponent {
            @inject logService: ILogService;
    
            constructor(context?: DiContainer) {
                setDiContext(this, context);
            }
        }
        // Or from external
        var someComponent = new SomeComponent();
        setDiContext(someComponent, GlobalContainer);
    
    1. If this object have no context, then looks for @DiContext decorator value. You can pass some own global context to it.

       import {inject, DiContainer, DiContext} from "typedin";
      
       var MyGlobalContext = new DiContainer();
      
       @DiContext(() => MyGlobalContext)
       class SomeComponent {
           @inject logService: ILogService;
       }
      
    2. If on steps 1 and 2 container not found, then Global container is selected.

    Injecting values

    You can inject any values as well as a services, just use @injectThe decorator, instead of @inject. Key can be any object comparable via '==' operator.

    import {injectThe, Global} from "typedin";
    
    enum MagicValues {
        LifeMeaning
    }
    
    Global.register(MagicValues.LifeMeaning, 42);
    
    class SomeComponent {
        @injectThe(MagicValues.LifeMeaning) lifeMeaning: number;
    }
    

    Inheritance of the containers

    Containers can be inherited one from another. If container not found value, it will continue search in parent container. In example we override LifeMeaning value in derived container, but DevilNumber will be received from parent.

    import {inject, Global, seDiContext} from "typedin";
    
    enum MagicValues {
        LifeMeaning,
        DevilNumber
    }
    
    Global.registerValue(MagicValues.LifeMeaning, 42);
    Global.registerValue(MagicValues.DevilNumber, 666);
    
    class SomeComponent {
        @inject(MagicValues.LifeMeaning) lifeMeaning: number;
        @inject(MagicValues.DevilNumber) devilNumber: number;
    }
    
    // Create myContext inherited from Global
    let myContext = new DiContainer(Global);
    // My context will have only LifeMeaning, DevilNumber it will get from parent.
    myContext.register(MagicValues.LifeMeaning, 24);
    
    var obj = new SomeComponent();
    setDiContext(obj, myContext);
    

    Cahcing and cache update

    Injected values are cached after first access. Cache is invalidates when you change something in container, or in some of the parent containers (for example, register new value).

    import {inject, Global, seDiContext} from "typedin";
    
    class SomeComponent {
        @inject(MagicValues.LifeMeaning) lifeMeaning: number;
    }
    var some = new SomeComponent();
    
    Global.registerValue(MagicValues.LifeMeaning, 42);
    console.info(some.lifeMeaning); // 42
    console.info(some.lifeMeaning); // 42 from cache
    // Next row change container, cache will be invalidated. 
    // Note, parent container change also invalidates a cache.
    Global.registerValue(MagicValues.LifeMeaning, 24); 
    console.info(some.lifeMeaning); // 24

    Install

    npm i typedin

    DownloadsWeekly Downloads

    6

    Version

    1.0.0

    License

    MIT

    Last publish

    Collaborators

    • pfight