|
|
import { Descriptor, ILifetime, DepsMap, Ref, IActivationContext } from "./interfaces";
|
|
|
import { each, isKey, key } from "./traits";
|
|
|
|
|
|
export type RegistrationOverridesMap<S extends object> = { [k in keyof S]?: Descriptor<S, NonNullable<S[k]>> };
|
|
|
|
|
|
export interface DescriptorImplArgs<S extends object, T> {
|
|
|
lifetime: ILifetime<T>;
|
|
|
|
|
|
factory: (refs: Record<key, never>) => T;
|
|
|
|
|
|
cleanup?: (item: T) => void;
|
|
|
|
|
|
overrides?: RegistrationOverridesMap<S>;
|
|
|
|
|
|
dependencies?: DepsMap<key, keyof S>;
|
|
|
}
|
|
|
|
|
|
|
|
|
export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
|
|
|
|
|
|
private readonly _overrides?: RegistrationOverridesMap<S>;
|
|
|
|
|
|
private readonly _lifetime: ILifetime<T>;
|
|
|
|
|
|
private readonly _factory: (refs: Record<key, never>) => T;
|
|
|
|
|
|
private readonly _cleanup?: (item: T) => void;
|
|
|
|
|
|
private readonly _deps?: DepsMap<key, keyof S>;
|
|
|
|
|
|
constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
|
|
|
this._lifetime = lifetime;
|
|
|
this._factory = factory;
|
|
|
if (cleanup)
|
|
|
this._cleanup = cleanup;
|
|
|
if (overrides)
|
|
|
this._overrides = overrides;
|
|
|
if (dependencies)
|
|
|
this._deps = dependencies;
|
|
|
}
|
|
|
|
|
|
activate(context: IActivationContext<S>): T {
|
|
|
|
|
|
if (this._lifetime.has())
|
|
|
return this._lifetime.get();
|
|
|
|
|
|
this._lifetime.initialize(context);
|
|
|
|
|
|
if (this._overrides)
|
|
|
each(this._overrides, (v, k) => context.register(k, v));
|
|
|
|
|
|
const resolve = <K extends keyof S, L extends boolean, D = never>({ name, lazy, ...opts }: Ref<K, L, D>) => {
|
|
|
if (lazy) {
|
|
|
return () => "default" in opts ? context.resolve(name, opts.default) : context.resolve(name);
|
|
|
} else {
|
|
|
return "default" in opts ? context.resolve(name, opts.default) : context.resolve(name);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
const makeRefs = (deps: typeof this._deps) => deps ?
|
|
|
Object.keys(deps)
|
|
|
.map(k => {
|
|
|
const ref = deps[k];
|
|
|
return isKey(ref) ?
|
|
|
{ [k]: resolve({ name: ref }) } :
|
|
|
{ [k]: resolve(ref) };
|
|
|
})
|
|
|
.reduce((a, p) => ({ ...a, ...p }), {} ) as Record<key, never>:
|
|
|
{} as Record<key, never>;
|
|
|
|
|
|
const instance = this._factory.call(undefined, makeRefs(this._deps));
|
|
|
|
|
|
this._lifetime.store(instance, this._cleanup);
|
|
|
|
|
|
return instance;
|
|
|
}
|
|
|
|
|
|
|
|
|
toString() {
|
|
|
return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
|
|
|
}
|
|
|
}
|
|
|
|
