## Description
This is a tiny library that brings Dependency-Injection to Typescript. There are several competing libraries out there, but this one is unique in the sense
that:
- It is _seriously_ small.
- It does its work on compile-time. The only runtime dependency is the `DIContainer` itself.
- It doesn't ask you to reflect metadata or to annotate your classes with decorators. _"It just works"_.
- It maps interfaces to implementations. Most popular dependency injection systems for TypeScript doesn't do this. This allows you to truly decouple an abstraction from its implementation.
- It supports the .NET generic reflection flavour: `registerSingleton()`. No need for anything else.
This library provides constructor-based dependency injection. This means that your classes will receive dependency-injected services as arguments to their constructors.
This library is a runtime dependency, but you need to transform your code with the [`DI Custom Transformer`](https://github.com/wessberg/di-compiler) as part of your Typescript compilation step to make the reflection work.
## Backers
### Patreon
## Table of Contents
- [Description](#description)
- [Backers](#backers)
- [Patreon](#patreon)
- [Table of Contents](#table-of-contents)
- [Install](#install)
- [npm](#npm)
- [Yarn](#yarn)
- [pnpm](#pnpm)
- [Usage](#usage)
- [Registering services](#registering-services)
- [Retrieving instances of services](#retrieving-instances-of-services)
- [Injecting instances of services into classes](#injecting-instances-of-services-into-classes)
- [Getting instances directly from the `DIContainer`](#getting-instances-directly-from-the-dicontainer)
- [Contributing](#contributing)
- [FAQ](#faq)
- [This is pure magic. How does it work?](#this-is-pure-magic-how-does-it-work)
- [Is it possible to have multiple, scoped containers?](#is-it-possible-to-have-multiple-scoped-containers)
- [License](#license)
## Install
### npm
```
$ npm install @wessberg/di
```
### Yarn
```
$ yarn add @wessberg/di
```
### pnpm
```
$ pnpm add @wessberg/di
```
## Usage
This library is meant to be super straightforward, super simple to use.
The following examples hopefully shows that:
### Registering services
To register services, simply instantiate a new service container and add services to it.
Here's several examples of how you may do that:
```typescript
import {DIContainer} from "@wessberg/di";
// Instantiate a new container for services
const container = new DIContainer();
// Register the service as a Singleton. Whenever the 'IMyService' service is requested,
// the same instance of MyService will be injected
container.registerSingleton();
// Register the service as a Transient. Whenever the 'IMyService' service is requested,
// a new instance of MyService will be injected
container.registerTransient();
// Rather than mapping a class to an interface,
// here we provide a function that returns an object that implements
// the required interface
container.registerSingleton(() => myAppConfig);
// You don't have to map an interface to an implementation.
container.registerSingleton();
```
### Retrieving instances of services
#### Injecting instances of services into classes
...Works completely automatically. As long as your class is constructed via
a `DIContainer`, and as long as the services it depends on are registered,
the class will receive the services as arguments to its' constructor:
```typescript
class MyClass {
constructor(
private myService: IMyService,
private myOtherService: IMyOtherService,
private myAwesomeService: MyAwesomeService
) {}
}
```
The true power of this library in comparison to others is that all of this mapping happens on compile-time.
This is what enables you to depend on interfaces, rather than objects that live on runtime.
#### Getting instances directly from the `DIContainer`
Sure, you can do that if you want to:
```typescript
// Gets a concrete instance of 'IMyService'. The implementation will
// depend on what you provided when you registered the service
const service = container.get();
```
## Contributing
Do you want to contribute? Awesome! Please follow [these recommendations](./CONTRIBUTING.md).
## FAQ
#### This is pure magic. How does it work?
It may look like it, but I assure you it is quite simple. [Read this answer for an explanation](https://github.com/wessberg/di-compiler#how-does-it-work-exactly).
#### Is it possible to have multiple, scoped containers?
Sure. You can instantiate as many as you want to, as long as you make sure the [Custom Transformer for DI](https://github.com/wessberg/di-compiler) get's to see the files that contain them.
## License
MIT ©