LifetimeManager.ts
174 lines
| 4.7 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r12 | import { IDestroyable, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces"; | ||
|
cin
|
r1 | import { argumentNotNull, isDestroyable } from "./traits"; | ||
|
cin
|
r0 | |||
|
cin
|
r1 | const safeCall = (item: () => void) => { | ||
|
cin
|
r0 | try { | ||
| item(); | ||||
| } catch { | ||||
| // silence! | ||||
| } | ||||
|
cin
|
r1 | }; | ||
|
cin
|
r0 | |||
|
cin
|
r12 | const noop = () => { }; | ||
|
cin
|
r11 | |||
|
cin
|
r12 | const fail = (message: string) => (): never => { | ||
|
cin
|
r11 | throw new Error(message); | ||
| }; | ||||
|
cin
|
r10 | const _emptySlot = Object.freeze({ | ||
| has: () => false, | ||||
|
cin
|
r0 | |||
|
cin
|
r11 | initialize: noop, | ||
| get: fail("The specified item isn't registered with a lifetime manager"), | ||||
|
cin
|
r0 | |||
|
cin
|
r11 | store: noop, | ||
|
cin
|
r0 | |||
|
cin
|
r12 | remove: noop, | ||
|
cin
|
r10 | |||
|
cin
|
r12 | cleanup: noop, | ||
|
cin
|
r0 | }); | ||
|
cin
|
r13 | const _destroy = (item: unknown) => () => isDestroyable(item) && item.destroy() ; | ||
|
cin
|
r10 | |||
|
cin
|
r12 | const _makeCleanup = <T>(value: T, cleanup?: (item: T) => void) => | ||
|
cin
|
r13 | cleanup ? () => cleanup(value) : _destroy(value); | ||
|
cin
|
r12 | |||
| const newSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({ | ||||
|
cin
|
r10 | has: () => false, | ||
|
cin
|
r12 | initialize: () => put(pendingSlot(put, remove)), | ||
| get: fail("The slot doesn't hold a value"), | ||||
|
cin
|
r10 | |||
|
cin
|
r12 | store: (value, cleanup) => put(valueSlot(value, cleanup, remove)), | ||
|
cin
|
r10 | |||
|
cin
|
r12 | remove: noop, | ||
| cleanup: noop, | ||||
|
cin
|
r10 | }); | ||
|
cin
|
r12 | const pendingSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({ | ||
| has: () => false, | ||||
| get: fail("The value in this slot doesn't exist"), | ||||
| initialize: fail("Cyclic reference detected"), | ||||
| store: (value, cleanup) => put(valueSlot(value, cleanup, remove)), | ||||
| remove, | ||||
| cleanup: noop | ||||
| }); | ||||
| const valueSlot = <T>(value: T, cleanup: ((item: T) => void) | undefined, remove: () => void) => ({ | ||||
|
cin
|
r10 | has: () => true, | ||
| get: () => value, | ||||
|
cin
|
r12 | initialize: fail("The slot already has a value"), | ||
| store: fail("The slot already has a value"), | ||||
|
cin
|
r10 | |||
|
cin
|
r12 | cleanup: _makeCleanup(value, cleanup), | ||
| remove: remove | ||||
|
cin
|
r10 | }); | ||
|
cin
|
r9 | export class LifetimeManager implements ILifetimeManager { | ||
|
cin
|
r0 | private _destroyed = false; | ||
|
cin
|
r10 | private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {}; | ||
|
cin
|
r1 | |||
|
cin
|
r12 | slot<T>(cookie: string | number): ILifetimeSlot<T> { | ||
|
cin
|
r10 | if (cookie in this._slots) | ||
| return this._slots[cookie] as ILifetimeSlot<T>; | ||||
|
cin
|
r0 | |||
|
cin
|
r12 | return newSlot<T>(this._put(cookie), this._remove(cookie)); | ||
|
cin
|
r0 | } | ||
|
cin
|
r12 | private readonly _put = (id: string | number) => <T>(slot: ILifetimeSlot<T>) => { | ||
| this._assertNotDestroyed(); | ||||
| this._slots[id] = slot as ILifetimeSlot<unknown>; | ||||
| }; | ||||
| private readonly _remove = (id: string | number) => () => { | ||||
| this._assertNotDestroyed(); | ||||
| delete this._slots[id]; | ||||
| }; | ||||
|
cin
|
r11 | |||
|
cin
|
r10 | private _assertNotDestroyed() { | ||
| if (this._destroyed) | ||||
| throw new Error("The lifetime manager is destroyed"); | ||||
| } | ||||
|
cin
|
r0 | destroy() { | ||
| if (!this._destroyed) { | ||||
| this._destroyed = true; | ||||
|
cin
|
r12 | Object.values(this._slots).forEach(({ cleanup }) => safeCall(cleanup)); | ||
|
cin
|
r0 | } | ||
| } | ||||
|
cin
|
r9 | } | ||
|
cin
|
r12 | export const emptyLifetime = <T>() => () => _emptySlot as ILifetimeSlot<T>; | ||
|
cin
|
r0 | |||
|
cin
|
r12 | let nextId = 1; | ||
|
cin
|
r0 | |||
|
cin
|
r13 | export const containerLifetime = <T>() => { | ||
| const slotId = nextId ++; | ||||
| return (context: ILifetimeContext) => | ||||
| context.ownerSlot<T>(slotId); | ||||
| }; | ||||
|
cin
|
r12 | export const hierarchyLifetime = <T>() => { | ||
| const slotId = nextId++; | ||||
| return (context: ILifetimeContext) => | ||||
| context.containerSlot<T>(slotId); | ||||
|
cin
|
r9 | }; | ||
|
cin
|
r0 | |||
|
cin
|
r10 | /** | ||
| * 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. | ||||
| */ | ||||
|
cin
|
r12 | export const contextLifetime = <T>() => { | ||
| const slotId = nextId++; | ||||
| return (context: ILifetimeContext) => | ||||
| context.contextSlot<T>(slotId); | ||||
|
cin
|
r9 | }; | ||
|
cin
|
r0 | |||
|
cin
|
r12 | const singletons = new LifetimeManager(); | ||
|
cin
|
r10 | /** | ||
| * 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 | ||||
| */ | ||||
|
cin
|
r12 | export const singletonLifetime = <T>(typeId: string) => { | ||
|
cin
|
r9 | argumentNotNull(typeId, "typeId"); | ||
|
cin
|
r12 | |||
| return () => singletons.slot<T>(typeId); | ||||
|
cin
|
r9 | }; | ||
|
cin
|
r10 | /** Creates a lifetime bound to the specified container. Using this lifetime | ||
| * will create a single service instance per the specified container. | ||||
| * | ||||
| * @param container The container which will manage the lifetime for the service | ||||
| */ | ||||
|
cin
|
r12 | export const containerLifetime = <T>(manager: ILifetimeManager) => { | ||
| const slotId = nextId++; | ||||
| return () => manager.slot<T>(slotId); | ||||
|
cin
|
r9 | }; | ||