@vert/core/doc/05.use-injector.md

Library to build OOP applications which are based on Vue.

# Use injector.

Injector is something to create instance of your classes.

Classes in same injector can reference each other by using injection.

```typescript
// Your services.

import { Injectable } from '@vert/core'

@Injectable()
class Logger {
  // ...
}

@Injectable()
class Http {
  // ...
  constructor (
    private logger: Logger
  ) {}
}

@Injectable()
class BookshelfService {
  // ...
  constructor (
    private http: Http,
    private logger: Logger
  ) {}
}

@Injectable()
class UserService {
  // ...
  constructor (
    private http: Http,
    private logger: Logger
  ) {}
}

export {
  BookshelfService,
  Http,
  Logger,
  UserService
}
```

```typescript
// Using injector.

import { Injector } from '@vert/core'
import { BookshelfService, Http, Logger, UserService } from './services'

// Create an injector.
const injector = Injector.create()
injector.addTransient(BookshelfService, Http, Logger, UserService)

// Get instances.
const bookshelfSrv = injector.get(BookshelfService)
const userSrv = injector.get(UserService)
```

You can register your service as transient-service or singleton-service:

```typescript
injector
  .addTransient(BookshelfService)
  .addSingleton(UserService)

const bookshelfSrv1 = injector.get(BookshelfService)
const bookshelfSrv2 = injector.get(BookshelfService)
bookshelfSrv1 === bookshelfSrv2  // false

const userSrv1 = injector.get(UserService)
const userSrv2 = injector.get(UserService)
userSrv1 === userSrv2  // true
```

## API

```typescript
/**
 * Standalone injector class.
 */
class Injector {
  /**
   * Create a new class injector.
   *
   * @return {Injector}
   */
  static create (): Injector

  /**
   * Register target as a singleton provider.
   * You will get the same instance in every single initialization.
   *
   * @param {TConstructor} Provider
   */
  addSingleton (Provider: TConstructor): this

  /**
   * Register target as transient provider.
   * You will get different instances in every single initialization.
   *
   * @param {TConstructor} Provider
   */
  addTransient <T> (Provider: TConstructor): this

  /**
   * Get target instance from injector by providing provider.
   *
   * @param {{new(...args): T}} Provider
   * @return {T}
   */
  get <T> (Provider: new (...args: any[]) => T): T

  /**
   * Check whether injector has registered this provider.
   *
   * @param target
   */
  has (target: TConstructor): boolean

  private constructor ()
}
```