# Dependency manager

This lib provides a simplistic dependency manager.

## Features and limitations

- It resolves dependencies only when they are needed
- It detect circular dependency

## Usage

Create a manager:

```typescript
import { DependencyManager } from 'dependency-manager/mod.ts'

const manager = new DependencyManager()
```

Create providers for your dependencies.
A provider is a function that is called when attempting to retrieve the dependency for the first time.
It receive the dependency manager, and return the dependency value, or a promise that resolves to it.

```typescript
// dependency-free provider
function loggerProvider() {
  return console.log
}
type Logger = ReturnType<typeof loggerProvider>;

// provider that need the 'logger' dependency
async function fooProvider(manager: DependencyManager) {
  const logger = await manager.resolve<Logger>('logger');

  return {
    bar: () => logger('bar'),
    baz: () => logger('baz'),
  }
}
type Foo = Awaited<ReturnType<typeof fooProvider>>;
```

Register the dependency by passing the `register` method its name and provider:

```typescript
manager.register('logger', loggerProvider);
manager.register('foo', fooProvider);
```

Retrieve dependencies by resolving them (always asynchrone, even if the provider was synchrone):

```typescript
const foo = await manager.resolve<Foo>('foo');
foo.bar();
foo.baz();
```

## Typing

Types should be explicitly defined when resolving a dependency.

## Errors

The `register` method throw an error if:
- the name is already used.

The `resolve` method throw an error if:
- the name doesn't exist (if no module has been registred with the given name).
- a circular dependency is detected