This is an internal function optimized for performance. Users should use @inject(key) or ctx.get(key) instead.

Get the value bound to this key. Depending on isSync, this function returns either:

• the bound value
• a promise of the bound value

Consumers wishing to consume sync values directly should use isPromise to check the type of the returned value to decide how to handle it.

const result = binding.getValue(ctx);
if (isPromise(result)) {
  result.then(doSomething)
} else {
  doSomething(result);
}

Bind the key to a constant value. The value must be already available at binding time, it is not allowed to pass a Promise instance.

Bind the key to an instance of the given class.

Bind the key to a computed (dynamic) value.

Bind the key to a value computed by a Provider.

• @example

export class DateProvider implements Provider<Date> {
  constructor(@inject('stringDate') private param: String){}
  value(): Date {
    return new Date(param);
  }
}

Get a binding address for retrieving a deep property of the object bound to the current binding key.

Create a new key for a binding bound to a value of type ValueType.

Example

BindingKey.create<string>('application.name');
BindingKey.create<number>('config', 'rest.port);
BindingKey.create<number>('config#rest.port');

Parse a string containing both the binding key and the path to the deeply nested property to retrieve.

Validate the binding key format. Please note that # is reserved. Returns a string representation of the binding key.

Context provides an implementation of Inversion of Control (IoC) container

Create a new context

Create a binding with the given key in the context. If a locked binding already exists with the same key, an error will be thrown.

Check if a binding exists with the given key in the local context without delegating to the parent context

Find bindings using the key pattern

Find bindings using a filter function

Find bindings using the tag pattern

Get the value bound to the given key, throw an error when no value was bound for the given key.

Get the value bound to the given key, optionally return a (deep) property of the bound value.

Look up a binding by key in the context and its ancestors. If no matching binding is found, an error will be thrown.

Look up a binding by key in the context and its ancestors. If no matching binding is found and options.optional is not set to true, an error will be thrown.

Get the owning context for a binding key

Get the synchronous value bound to the given key, optionally return a (deep) property of the bound value.

This method throws an error if the bound value requires async computation (returns a promise). You should never rely on sync bindings in production code.

Get the synchronous value bound to the given key, optionally return a (deep) property of the bound value.

This method throws an error if the bound value requires async computation (returns a promise). You should never rely on sync bindings in production code.

Get the value bound to the given key.

This is an internal version that preserves the dual sync/async result of Binding#getValue(). Users should use get() or getSync() instead.

Check if a key is bound in the context or its ancestors

Create a plain JSON object for the context

Unbind a binding from the context. No parent contexts will be checked. If you need to unbind a binding owned by a parent context, use the code below:

const ownerCtx = ctx.getOwnerContext(key);
return ownerCtx != null && ownerCtx.unbind(key);

Descriptor for an injection point

An object to provide metadata for @inject

A function to provide resolution of injected values

The function injected by `@inject.getter(key)`.

The function injected by `@inject.setter(key)`.

Providers allow developers to compute injected values dynamically, with any dependencies required by the value getter injected automatically from the Context.

Object to keep states for a session to resolve bindings and their dependencies within a context

Get the binding path as bindingA --> bindingB --> bindingC.

Get the injection path as injectionA --> injectionB --> injectionC.

Get the resolution path including bindings and injections, for example: bindingA --> @ClassA[0] --> bindingB --> @ClassB.prototype.prop1 --> bindingC.

Exit the resolution of a binding

Pop the last injection

Enter the resolution of the given binding. If

Push the injection onto the session

Describe the injection for debugging purpose

Fork the current session so that a new one with the same stack can be used in parallel or future resolutions, such as multiple method arguments, multiple properties, or a getter function

Run the given action with the given binding and session

Run the given action with the given injection and session

Wrapper for bindings tracked by resolution sessions

Wrapper for injections tracked by resolution sessions

Options for binding/dependency resolution

A function to be executed with the resolution session