TypeScript inversify-inject-decorators.default函数代码示例

function getDecorators(kernel: inversify.interfaces.Kernel, store: Redux.Store<any>) {

    // TODO: Should binding be declared by user?
    let storeId = Symbol("Redux.Store");
    kernel.bind<Redux.Store<any>>(storeId).toConstantValue(store);

    let {
        lazyInject,
        lazyInjectNamed,
        lazyInjectTagged,
        lazyMultiInject
    } = getInjectDecorators(kernel);

    let provide = makeProvideDecorator(kernel);
    let provideFluent = makeFluentProvideDecorator(kernel);

    let provideSingleton = function(identifier: inversify.interfaces.ServiceIdentifier<any>) {
        return provideFluent(identifier).inSingletonScope().done();
    };

    let provideNamed = function(identifier: inversify.interfaces.ServiceIdentifier<any>, name: string) {
        return provideFluent(identifier).whenTargetNamed(name).done();
    };

    let provideTagged = function(identifier: inversify.interfaces.ServiceIdentifier<any>, key: string, value: any) {
        return provideFluent(identifier).whenTargetTagged(key, value).done();
    };

    // Decorator used to inject props mapped from the state into a class property
    let injectProps = (mapStateToProps: (state: any) => any) => {
        return function(proto: any, key: string): void {
            let state = store.getState();
            // todo subscribe to changes
            let props = mapStateToProps(state);
            let resolve = () => { return props; };
            proxyGetter(proto, key, resolve);
        };
    };

    // Decorator used to bind action creators and inject them into a class property
    let injectActions = (actionCreatorsIdentifier: inversify.interfaces.ServiceIdentifier<any>) => {
        return function(proto: any, key: string): void {
            let dispatch = store.dispatch;
            let actionCreators = kernel.get(actionCreatorsIdentifier);
            let boundActionCreators = Redux.bindActionCreators(actionCreators, dispatch);
            let resolve = () => { return kernel.get(actionCreatorsIdentifier); };
            proxyGetter(proto, key, resolve);
        };
    };

    return {
        provide,
        provideNamed,
        provideTagged,
        provideSingleton,
        provideFluent,
        injectProps,
        injectActions,
        lazyInject,
        lazyInjectNamed,
        lazyInjectTagged,
        lazyMultiInject
    };

}

import getDecorators from "inversify-inject-decorators";
import { Container } from 'inversify';

const ioc: Container = new Container();
const decorators = getDecorators(ioc);
const inject = decorators.lazyInject;

import { iocModule as commonIocModule } from '../ui/common/iocModule';
import { iocModule as todoIocModule } from '../ui/todo/iocModule';
// import { iocModule as todo2IocModule } from '../ui/todo2/iocModule';

ioc.load(
    commonIocModule,
    todoIocModule
);

// if (Math.random() >= 0.5) {
//     ioc.load(todo2IocModule);
// }

export { ioc, inject };

import { Kernel } from "inversify";
import { decorate, injectable, inject, interfaces } from "inversify";
import getDecorators from "inversify-inject-decorators";
import { makeProvideDecorator } from "inversify-binding-decorators";

let kernel = new Kernel();
let {lazyInject} = getDecorators(kernel);
let provide = makeProvideDecorator(kernel);

export { kernel, lazyInject, provide };

import getDecorators from "inversify-inject-decorators";
import { Kernel, injectable, tagged, named } from "inversify";

module lazyInject {

  let kernel = new Kernel();
  let { lazyInject } = getDecorators(kernel);
  let TYPES = { Weapon: "Weapon" };

  interface Weapon {
      name: string;
      durability: number;
      use(): void;
  }

  @injectable()
  class Sword implements Weapon {
      public name: string;
      public durability: number;
      public constructor() {
          this.durability = 100;
          this.name = "Sword";
      }
      public use() {
          this.durability = this.durability - 10;
      }
  }

  class Warrior {
      @lazyInject(TYPES.Weapon)
      public weapon: Weapon;