|
|
import { ActivationError, ActivationItem } from "./ActivationError";
|
|
|
import { IActivationContext, DescriptorMap, ILifetimeManager, ILifetimeSlot, ServiceLocator, IContainerBuilder } from "../typings/interfaces";
|
|
|
import { argumentNotNull, each, prototype } from "./traits";
|
|
|
import { LifetimeManager } from "./LifetimeManager";
|
|
|
import { ContainerBuilder } from "./ContainerBuilder";
|
|
|
|
|
|
/** This object is created once per `Container.resolve` method call and used to
|
|
|
* cache dependencies and to track created instances. The activation context
|
|
|
* tracks services with `context` activation type.
|
|
|
*
|
|
|
* @template S The service map used in the activation context, services from
|
|
|
* this map are available to resolution.
|
|
|
* @template U A set of keys from the service map which can be overridden in
|
|
|
* this activation context.
|
|
|
*/
|
|
|
export class ActivationContext<S> implements IActivationContext<S> {
|
|
|
|
|
|
private readonly _container: ServiceLocator<S>;
|
|
|
|
|
|
private readonly _contextScope: ILifetimeManager;
|
|
|
|
|
|
private _services: DescriptorMap<S>;
|
|
|
|
|
|
private readonly _scope: ILifetimeManager[];
|
|
|
|
|
|
/** Creates a new activation context with the specified parameters.
|
|
|
* @param containerLifetimeManager the container which starts the activation process
|
|
|
* @param services the initial service registrations
|
|
|
* @param name the name of the service being activated, this parameter is
|
|
|
* used for the debug purpose.
|
|
|
* @param service the service to activate, this parameter is used for the
|
|
|
* debug purpose.
|
|
|
*/
|
|
|
constructor(container: ServiceLocator<S>, scope: ILifetimeManager[], services: DescriptorMap<S>, contextScope: ILifetimeManager = new LifetimeManager()) {
|
|
|
this._container = container;
|
|
|
this._contextScope = contextScope;
|
|
|
this._services = services;
|
|
|
this._scope = scope;
|
|
|
}
|
|
|
|
|
|
resolve<K extends keyof S>(name: K, stack: ActivationItem[]): NonNullable<S[K]>;
|
|
|
resolve<K extends keyof S, T>(name: K, stack: ActivationItem[], def: T): NonNullable<S[K]> | T;
|
|
|
resolve<K extends keyof S, T>(name: K, stack: ActivationItem[], def?: T): NonNullable<S[K]> | T | undefined {
|
|
|
const service = this._services[name];
|
|
|
|
|
|
if (service !== undefined) {
|
|
|
return service.activate(
|
|
|
this,
|
|
|
stack.concat({
|
|
|
name: name.toString(),
|
|
|
descriptor: service.toString()
|
|
|
})
|
|
|
);
|
|
|
} else {
|
|
|
if (arguments.length > 2)
|
|
|
return def;
|
|
|
else
|
|
|
throw new Error("Service not found");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* registers services local to the the activation context
|
|
|
*
|
|
|
* @name{string} the name of the service
|
|
|
* @service{string} the service descriptor to register
|
|
|
*/
|
|
|
private _register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]) {
|
|
|
argumentNotNull(name, "name");
|
|
|
|
|
|
const d = this._services[name];
|
|
|
if (d !== undefined && !d.configurable)
|
|
|
throw new Error(`Service ${String(name)} can't be overridden`);
|
|
|
|
|
|
this._services[name] = service;
|
|
|
}
|
|
|
|
|
|
scopeSlot<T>(level: number, slotId: string | number): ILifetimeSlot<T> {
|
|
|
if (level < 0 || level >= this._scope.length)
|
|
|
throw new Error("The scope level is out of range");
|
|
|
return this._scope[level].slot(slotId);
|
|
|
}
|
|
|
|
|
|
hierarchySlot<T>(slotId: string | number): ILifetimeSlot<T> {
|
|
|
return this._scope[this._scope.length - 1].slot(slotId);
|
|
|
}
|
|
|
|
|
|
selfContainer(): ServiceLocator<S> {
|
|
|
return this._container;
|
|
|
}
|
|
|
|
|
|
createChildContainer(): IContainerBuilder<S, keyof S> {
|
|
|
return new ContainerBuilder(this._services, this._scope);
|
|
|
}
|
|
|
|
|
|
contextSlot<T>(slotId: string | number): ILifetimeSlot<T> {
|
|
|
return this._contextScope.slot(slotId);
|
|
|
}
|
|
|
|
|
|
withOverrides<X>(overrides: DescriptorMap<S>, action: () => X) {
|
|
|
const services = this._services;
|
|
|
this._services = prototype(this._services);
|
|
|
try {
|
|
|
each(overrides, (v, k) => this._register(k, v));
|
|
|
return action();
|
|
|
} finally {
|
|
|
this._services = services;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
