Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/otbe/di
Simple DI written for TypeScript
https://github.com/otbe/di
Last synced: about 2 months ago
JSON representation
Simple DI written for TypeScript
- Host: GitHub
- URL: https://github.com/otbe/di
- Owner: otbe
- License: mit
- Created: 2017-05-19T14:43:46.000Z (over 7 years ago)
- Default Branch: master
- Last Pushed: 2018-08-10T08:59:57.000Z (over 6 years ago)
- Last Synced: 2024-11-17T06:16:20.584Z (about 2 months ago)
- Language: TypeScript
- Homepage:
- Size: 234 KB
- Stars: 1
- Watchers: 3
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# simple-ts-di
[](https://travis-ci.org/otbe/di)
Simple DI framework written in and for TypeScript.
By default all bindings are in singleton scope. Where possible you can call a ```transient()``` binder function to create a transient binding.
## Setup
Make sure your ```tsconfig.json``` contains
```json
{
"experimentalDecorators": true,
"emitDecoratorMetadata": true
}
```
Install ```reflect-metadata``` and include it somewhere.
Make sure your setup supports Maps and Symbols.
## Example
### Constructor injection
```typescript
class Service {
sayHi() { return 'hi'; }
}
@inject()
class Test {
constructor(service: Service) {
service.sayHi();
}
}
class MyModule implements Module {
init(bind: Bind) {
bind(Service).transient(); // transient scope
bind(Test); // singleton scope
// shortcut for bind(Test).to(Test)
}
}
const container = new Container(new MyModule());
const test = container.get(Test);
```
### Property injection
```simple-ts-di``` supports property injection. It will only work if the type (here ```Service```) has a meaningful runtime representation. So it only works for classes (as of now). If you want to inject some primitives or a service which implements an interface you have to use named injection. If your environment dont let you control how the class is instantiated (e.g. react components are instantiated by react and not via container.get(...)), you can use a special version of inject - abounded inject. See "bounded property injection".
```typescript
class Service {
sayHi() { return 'hi'; }
}
class Test {
@inject()
private service: Service;
sayHelloToService() {
return this.service.sayHi();
}
}
class MyModule implements Module {
init(bind: Bind) {
bind(Service).transient(); // transient scope
bind(Test); // singleton scope
// shortcut for bind(Test).to(Test)
}
}
const container = new Container(new MyModule());
const test = container.get(Test);
```
### named injection
```typescript
const SERVICE = Symbol();
const PRIMITIVE = Symbol();
interface IService {
sayHi(): string;
}
class Service implements IService {
sayHi() { return 'hi'; }
}
@inject([SERVICE, PRIMITIVE])
class Test {
@inject(SERVICE)
private service: IService;
@inject(PRIMITIVE)
private primitive: number;
constructor(service: IService, primitive: number) {
}
}
class MyModule implements Module {
init(bind: Bind) {
bind(SERVICE).to(Service);
bind(PRIMITIVE).toValue(10);
bind(Test);
}
}
const container = new Container(new MyModule());
const test = container.get(Test);
```
### bounded property injection
```typescript
class Service {
sayHi() {
return 'hi';
}
}
class MyModule implements Module {
init(bind: Bind) {
bind(Service);
}
}
const container = new Container(new MyModule());
const bInject = createBoundedInject(container);
class Test {
@bInject() service: Service;
}
const t = new Test();
t.service.sayHi(); // returns Hi
```
See ```tests/``` for more complex examples and API.