# @karcass/container

> Simple IoC container

Latest version **0.1.5** (published 2020-02-18) · MIT license · 0 weekly downloads

## Install

```sh
npm install @karcass/container
pnpm add @karcass/container
yarn add @karcass/container
bun add @karcass/container
```

## Health

**Score 25/100 (F)** — status: abandoned.

Positive: has types; no vulnerabilities; high quality score.

Warnings: low downloads; no esm support; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.1.5 |
| Published | 2020-02-18 |
| First published | 2019-12-19 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | CommonJS |
| Dependencies | 3 |
| Unpacked size | 21.4 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 0 |
| Author | Valeriy Shibanov |
| Maintainers | shibaon |
| Keywords | IoC, container, karcass |

## Links

- npm: https://www.npmjs.com/package/@karcass/container
- Repository: https://github.com/karcass-ts/container
- Homepage: https://github.com/karcass-ts/container#readme
- Issues: https://github.com/karcass-ts/container/issues
- npm.io page: https://npm.io/package/@karcass/container

## Dependencies (3)

- [jest](https://npm.io/package/jest.md) ^25.1.0
- [@types/jest](https://npm.io/package/@types/jest.md) ^25.1.2
- [reflect-metadata](https://npm.io/package/reflect-metadata.md) ^0.1.13

## Alternatives

- [jsforce](https://npm.io/package/jsforce.md) — 851.2K weekly downloads
- [react-native-qrcode-svg](https://npm.io/package/react-native-qrcode-svg.md) — 693.5K weekly downloads
- [@salesforce/plugin-data](https://npm.io/package/@salesforce/plugin-data.md) — 394.9K weekly downloads
- [@backstage/plugin-search-common](https://npm.io/package/@backstage/plugin-search-common.md) — 308.5K weekly downloads
- [@chain-registry/types](https://npm.io/package/@chain-registry/types.md) — 38.4K weekly downloads

## Recent versions

- 0.1.5 (latest) — 2020-02-18
- 0.1.4 — 2020-02-07
- 0.1.3 — 2020-01-21
- 0.0.12 — 2019-12-23
- 0.0.5 — 2019-12-22
- 0.0.2 — 2019-12-19

## README

# @karcass/container

Very tiny and simple async IoC container with dependency injection support
used in <a href="https://github.com/karcass-ts/karcass">karcass</a> skeleton

# Installation

```
npm install @karcass/container
```

# Usage

```typescript
import { Container } from '@karcass/container'

class ConsoleLogger {
    public log(text: string) {
        console.log(text)
    }
}

class HelloMessagePrinter {
    public constructor(protected helloSayer: HelloSayer) {}

    public print(username: string) {
        this.helloSayer.log(`Hello, ${username}!`)
    }
}

class DummyClass {}

const container = new Container()

container.add(HelloWorldMessagePrinter, async () => {
    const logger = await container.get(ConsoleLogger)
    console.log('HelloMessagePrinter initialization...')
    return new HelloMessagePrinter(logger)
})
container.add(ConsoleLogger, () => {
    console.log('ConsoleLogger initialization...')
    return new ConsoleLogger()
}
container.add(DummyClass, () => {
    console.log('DummyClass initialization...')
    return new DummyClass()
})

container.get(HelloMessagePrinter).then(printer => printer.print('Alice'))
```

This example will print:

```
ConsoleLogger initialization...
HelloMessagePrinter initialization...
Hello, Alice!
```

Also you can use `addInplace` method for immediate initialization of some instances for some reasons:

```typescript
container.add(HelloWorldMessagePrinter, () => {
    const logger = container.get(ConsoleLogger)
    console.log('HelloMessagePrinter initialization...')
    return new HelloMessagePrinter(logger)
})
container.add(ConsoleLogger, () => {
    console.log('ConsoleLogger initialization...')
    return new ConsoleLogger()
}
container.addInplace(DummyClass, () => {
    console.log('DummyClass initialization... It was first.')
})

container.get(HelloMessagePrinter).print('Alice')
```

Ouput:

```
DummyClass initialization... It was first.
ConsoleLogger initialization...
HelloMessagePrinter initialization...
Hello, Alice!
```

You can use dependency injection instead of service construction by hands:

```typescript
import { Container, Dependency } from '@karcass/container'

class FirstClass {}

class SecondClass {
    public constructor(@Dependency(FirstClass) firstClassInstance: FirstClass) {
        console.log(`${firstClassInstance.constructor.name} loaded`)
    }
}

const container = new Container()
container.add(FirstClass)
await container.addInplace(SecondClass)
```

Or you can just create instance of SecondClass using `inject` method, which creates instance of constructor and injects corresponding dependencies. This method doesn't perform addition of created object into self (container's) index:

```typescript
const secondClassInstance = await container.inject(SecondClass)
```

Feel free to use text keys for services:

```typescript
/* ... */
public constructor(@Dependency('first-class') firstClassInstance: FirstClass) {
/* ... */
container.add('first-class', () => new FirstClass())
await container.addInplace(SecondClass)
```

# Available methods

* `add<T>(key: costructor | string, initializer?: () => T | Promise<T>): void`;
* `addInplace<T>(key: consructor | string, initializer?: () => T | Promise<T>): Promise<T>`;
* `get<T>(key: constructor | string): Promise<T>`;
* `getAll(): Promise<T[]>`;
* `getKeys(): (string | constructor)[]`.

---
_Source: https://npm.io/package/@karcass/container · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._