|
|
import { IActivationContext, ILifetime, ILifetimeManager } from "./interfaces";
|
|
|
import { ActivationContext } from "./ActivationContext";
|
|
|
import { argumentNotNull, isDestroyable } from "./traits";
|
|
|
|
|
|
const safeCall = (item: () => void) => {
|
|
|
try {
|
|
|
item();
|
|
|
} catch {
|
|
|
// silence!
|
|
|
}
|
|
|
};
|
|
|
|
|
|
const _emptyLifetime = Object.freeze({
|
|
|
has() {
|
|
|
return false;
|
|
|
},
|
|
|
|
|
|
initialize() {
|
|
|
},
|
|
|
|
|
|
get() {
|
|
|
throw new Error("The specified item isn't registered with this lifetime manager");
|
|
|
},
|
|
|
|
|
|
store() {
|
|
|
// does nothing
|
|
|
},
|
|
|
|
|
|
toString() {
|
|
|
return `[object EmptyLifetime]`;
|
|
|
}
|
|
|
|
|
|
});
|
|
|
|
|
|
const _unknownLifetime = Object.freeze({
|
|
|
has() {
|
|
|
return false;
|
|
|
},
|
|
|
initialize() {
|
|
|
throw new Error("Can't call initialize on the unknown lifetime object");
|
|
|
},
|
|
|
get() {
|
|
|
throw new Error("The lifetime object isn't initialized");
|
|
|
},
|
|
|
store() {
|
|
|
throw new Error("Can't store a value in the unknown lifetime object");
|
|
|
},
|
|
|
|
|
|
toString() {
|
|
|
return `[object UnknownLifetime]`;
|
|
|
}
|
|
|
});
|
|
|
|
|
|
let nextId = 0;
|
|
|
|
|
|
const singletons: { [K: string]: unknown } = {};
|
|
|
|
|
|
export class LifetimeManager implements ILifetimeManager {
|
|
|
private _cleanup: (() => void)[] = [];
|
|
|
private readonly _cache: { [K: string]: unknown } = {};
|
|
|
private _destroyed = false;
|
|
|
|
|
|
private readonly _pending: { [K: string]: unknown } = {};
|
|
|
|
|
|
create<T>(): ILifetime<T> & { remove(): void; } {
|
|
|
const id = ++nextId;
|
|
|
return {
|
|
|
has: () => id in this._cache,
|
|
|
|
|
|
get: () => {
|
|
|
const t = this._cache[id] as T;
|
|
|
if (t === undefined || t === null)
|
|
|
throw new Error(`The item with with the key ${id} isn't found`);
|
|
|
return t;
|
|
|
},
|
|
|
|
|
|
initialize: () => {
|
|
|
if (this._pending[id])
|
|
|
throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
|
|
|
this._pending[id] = true;
|
|
|
},
|
|
|
|
|
|
store: (item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) => {
|
|
|
if (id in this._cache)
|
|
|
throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
|
|
|
if (this._destroyed)
|
|
|
throw new Error("Lifetime manager is destroyed");
|
|
|
|
|
|
delete this._pending[id];
|
|
|
|
|
|
this._cache[id] = item;
|
|
|
|
|
|
if (cleanup) {
|
|
|
this._cleanup.push(() => cleanup(item));
|
|
|
} else if (isDestroyable(item)) {
|
|
|
this._cleanup.push(() => item.destroy());
|
|
|
}
|
|
|
},
|
|
|
|
|
|
remove: () => {
|
|
|
if (this._pending[id])
|
|
|
throw new Error(`The item '${id}' can't be removed before it has been stored`);
|
|
|
delete this._cache[id];
|
|
|
}
|
|
|
};
|
|
|
}
|
|
|
|
|
|
destroy() {
|
|
|
if (!this._destroyed) {
|
|
|
this._destroyed = true;
|
|
|
this._cleanup.forEach(safeCall);
|
|
|
this._cleanup.length = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
export const emptyLifetime = <T>(): ILifetime<T> => {
|
|
|
return _emptyLifetime;
|
|
|
};
|
|
|
|
|
|
export const hierarchyLifetime = <T>(): ILifetime<T> => {
|
|
|
let _lifetime: ILifetime<T> = _unknownLifetime;
|
|
|
return {
|
|
|
initialize(context: IActivationContext<object>) {
|
|
|
if (_lifetime !== _unknownLifetime)
|
|
|
throw new Error("Cyclic reference activation detected");
|
|
|
|
|
|
_lifetime = context.createContainerLifetime<T>();
|
|
|
},
|
|
|
get() {
|
|
|
return _lifetime.get();
|
|
|
},
|
|
|
has() {
|
|
|
return _lifetime.has();
|
|
|
},
|
|
|
store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
|
|
|
return _lifetime.store(item, cleanup);
|
|
|
},
|
|
|
toString() {
|
|
|
return `[object HierarchyLifetime, has=${String(this.has())}]`;
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
export const contextLifetime = <T>(): ILifetime<T> => {
|
|
|
let _lifetime: ILifetime<T> = _unknownLifetime;
|
|
|
return {
|
|
|
initialize(context: ActivationContext<object>) {
|
|
|
if (_lifetime !== _unknownLifetime)
|
|
|
throw new Error("Cyclic reference detected");
|
|
|
_lifetime = context.createLifetime();
|
|
|
},
|
|
|
get() {
|
|
|
return _lifetime.get();
|
|
|
},
|
|
|
has() {
|
|
|
return _lifetime.has();
|
|
|
},
|
|
|
store(item: NonNullable<T>) {
|
|
|
_lifetime.store(item);
|
|
|
},
|
|
|
toString() {
|
|
|
return `[object ContextLifetime, has=${String(this.has())}]`;
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
export const singletonLifetime = <T>(typeId: string): ILifetime<T> => {
|
|
|
argumentNotNull(typeId, "typeId");
|
|
|
let pending = false;
|
|
|
return {
|
|
|
has() {
|
|
|
return typeId in singletons;
|
|
|
},
|
|
|
get() {
|
|
|
if (!this.has())
|
|
|
throw new Error(`The instance ${typeId} doesn't exists`);
|
|
|
return singletons[typeId] as NonNullable<T>;
|
|
|
},
|
|
|
initialize() {
|
|
|
if (pending)
|
|
|
throw new Error("Cyclic reference detected");
|
|
|
pending = true;
|
|
|
},
|
|
|
store(item: NonNullable<T>) {
|
|
|
singletons[typeId] = item;
|
|
|
pending = false;
|
|
|
},
|
|
|
toString() {
|
|
|
return `[object SingletonLifetime, has=${String(this.has())}, typeId=${typeId}]`;
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
export const containerLifetime = <T>(container: { createLifetime<X>(): ILifetime<X> }) => {
|
|
|
let _lifetime: ILifetime<T> = _unknownLifetime;
|
|
|
return {
|
|
|
initialize() {
|
|
|
if (_lifetime !== _unknownLifetime)
|
|
|
throw new Error("Cyclic reference detected");
|
|
|
_lifetime = container.createLifetime();
|
|
|
},
|
|
|
get() {
|
|
|
return _lifetime.get();
|
|
|
},
|
|
|
has() {
|
|
|
return _lifetime.has();
|
|
|
},
|
|
|
store(item: NonNullable<T>) {
|
|
|
_lifetime.store(item);
|
|
|
},
|
|
|
toString() {
|
|
|
return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
