|
|
import { ILifetime, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "../typings/interfaces";
|
|
|
import { LifetimeSlot } from "./LifetimeSlot";
|
|
|
import { argumentNotNull } from "./traits";
|
|
|
|
|
|
const noop = () => { };
|
|
|
|
|
|
const fail = (message: string) => (): never => {
|
|
|
throw new Error(message);
|
|
|
};
|
|
|
|
|
|
const _emptySlot = Object.freeze({
|
|
|
has: () => false,
|
|
|
|
|
|
initialize: () => false,
|
|
|
|
|
|
get: fail("The specified item isn't registered with a lifetime manager"),
|
|
|
|
|
|
store: noop,
|
|
|
|
|
|
remove: noop,
|
|
|
|
|
|
cleanup: noop,
|
|
|
});
|
|
|
|
|
|
export class LifetimeManager implements ILifetimeManager {
|
|
|
private _destroyed = false;
|
|
|
|
|
|
private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};
|
|
|
|
|
|
slot<T>(slotId: string | number): ILifetimeSlot<T> {
|
|
|
if (this._destroyed)
|
|
|
throw new Error("The lifetime manager is destroyed");
|
|
|
|
|
|
if (slotId in this._slots)
|
|
|
return this._slots[slotId] as ILifetimeSlot<T>;
|
|
|
|
|
|
return this._slots[slotId] = new LifetimeSlot<T>(() => delete this._slots[slotId]);
|
|
|
}
|
|
|
|
|
|
|
|
|
destroy() {
|
|
|
if (!this._destroyed) {
|
|
|
this._destroyed = true;
|
|
|
Object.values(this._slots).forEach(slot => {
|
|
|
try {
|
|
|
slot.cleanup();
|
|
|
} catch {
|
|
|
// ignore
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
export const emptySlot = <T>() => _emptySlot as ILifetimeSlot<T>;
|
|
|
|
|
|
export const emptyLifetime = <T>() => emptySlot as ILifetime<T>;
|
|
|
|
|
|
export const scopeLifetime = <T>(level: number, slotId: string | number) =>
|
|
|
(context: ILifetimeContext) =>
|
|
|
context.scopeSlot<T>(level, slotId);
|
|
|
|
|
|
export const hierarchyLifetime = <T>(slotId: string | number) =>
|
|
|
(context: ILifetimeContext) =>
|
|
|
context.hierarchySlot<T>(slotId);
|
|
|
|
|
|
/**
|
|
|
* Creates a lifetime instance bound to the current activation context. This
|
|
|
* lifetime will store the service instance per activation context. Every
|
|
|
* top level service resolution will create a new activation context. This
|
|
|
* context is propagated to subsequent service resolution thus all services
|
|
|
* with context lifetime will be shared among their consumers.
|
|
|
*
|
|
|
* @returns The instance of the lifetime.
|
|
|
*/
|
|
|
export const contextLifetime = <T>(slotId: string | number) =>
|
|
|
(context: ILifetimeContext) =>
|
|
|
context.contextSlot<T>(slotId);
|
|
|
|
|
|
const singletons = new LifetimeManager();
|
|
|
|
|
|
/**
|
|
|
* Creates the lifetime for the service which will allow existence only one
|
|
|
* instance with the specified {@linkcode typeId}. If there will be created
|
|
|
* several lifetime instances with same `typeId` in the runtime, they will
|
|
|
* share the same service instance.
|
|
|
*
|
|
|
* @param typeId The identified for the global instance, usually this is a
|
|
|
* fully qualified class name
|
|
|
* @returns The lifetime instance
|
|
|
*/
|
|
|
export const singletonLifetime = <T>(typeId: string) => {
|
|
|
argumentNotNull(typeId, "typeId");
|
|
|
|
|
|
return () => singletons.slot<T>(typeId);
|
|
|
};
|
|
|
|
