|
|
import { Descriptor, ILifetime, IActivationContext, DescriptorMap, DescriptorDepsMap } from "../typings/interfaces";
|
|
|
import { ActivationError, ActivationItem } from "./ActivationError";
|
|
|
import { each, key } from "./traits";
|
|
|
|
|
|
export interface DescriptorImplArgs<S, T> {
|
|
|
|
|
|
readonly lifetime: ILifetime<T>;
|
|
|
|
|
|
readonly factory: (refs: Record<key, unknown>) => NonNullable<T>;
|
|
|
|
|
|
readonly cleanup?: (item: NonNullable<T>) => void;
|
|
|
|
|
|
readonly overrides?: DescriptorMap<S>;
|
|
|
|
|
|
readonly dependencies?: DescriptorDepsMap<S>;
|
|
|
}
|
|
|
|
|
|
export class DescriptorImpl<S, T> implements Descriptor<S, T> {
|
|
|
|
|
|
private readonly _overrides: DescriptorMap<S> | undefined;
|
|
|
|
|
|
private readonly _lifetime: ILifetime<T>;
|
|
|
|
|
|
private readonly _factory: (refs: Record<key, unknown>) => NonNullable<T>;
|
|
|
|
|
|
private readonly _cleanup: (item: NonNullable<T>) => void;
|
|
|
|
|
|
private readonly _dependencies: DescriptorDepsMap<S> | undefined;
|
|
|
|
|
|
constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
|
|
|
this._lifetime = lifetime;
|
|
|
this._factory = factory;
|
|
|
this._cleanup = cleanup ? cleanup : () => { };
|
|
|
this._overrides = overrides;
|
|
|
this._dependencies = dependencies;
|
|
|
}
|
|
|
|
|
|
activate(context: IActivationContext<S>, stack: ActivationItem[]): NonNullable<T> {
|
|
|
|
|
|
const slot = this._lifetime(context);
|
|
|
if (slot.has())
|
|
|
return slot.get();
|
|
|
|
|
|
if (!slot.initialize())
|
|
|
throw new Error("Cyclic reference detected");
|
|
|
|
|
|
const instance = this._overrides ?
|
|
|
context.withOverrides(this._overrides, () => this._activate(context, stack)) :
|
|
|
this._activate(context, stack);
|
|
|
|
|
|
slot.store(instance, this._cleanup);
|
|
|
|
|
|
return instance;
|
|
|
}
|
|
|
|
|
|
private _activate(context: IActivationContext<S>, stack: ActivationItem[]) {
|
|
|
const refs: Record<key, unknown> = {};
|
|
|
if (this._dependencies) {
|
|
|
const resolve = <K extends keyof S>({ name, lazy, ...opts }: { name: K; lazy?: boolean; default?: S[K]; }) => {
|
|
|
if (lazy) {
|
|
|
return "default" in opts ?
|
|
|
() => context.resolve(name, stack, opts.default) :
|
|
|
() => context.resolve(name, stack);
|
|
|
} else {
|
|
|
return "default" in opts ?
|
|
|
context.resolve(name, stack, opts.default) :
|
|
|
context.resolve(name, stack);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
// can throw activation exception
|
|
|
each(this._dependencies, (v, k) => {
|
|
|
refs[k] = resolve(v);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
try {
|
|
|
// call the factory method
|
|
|
return (0, this._factory)(refs);
|
|
|
} catch (e) {
|
|
|
throw new ActivationError("Error creating instance", stack, e);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
toString() {
|
|
|
return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
|
|
|
}
|
|
|
}
|
|
|
|
