DescriptorBuilder.ts
193 lines
| 6.3 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r9 | import { BuildDescriptorFn, IDescriptorBuilder, DepsMap, Resolve, DescriptorMap } from "./interfaces"; | ||
|
cin
|
r1 | import { Descriptor, ILifetime, ActivationType } from "./interfaces"; | ||
|
cin
|
r9 | import { DescriptorImpl } from "./DescriptorImpl"; | ||
| import { contextLifetime, emptyLifetime, hierarchyLifetime, LifetimeManager, singletonLifetime } from "./LifetimeManager"; | ||||
| import { each, isPromise, isString, key, oid } from "./traits"; | ||||
|
cin
|
r0 | |||
|
cin
|
r1 | /** | ||
| * @template {S} Карта доступных зависимостей, как правило `ContainerServices` | ||||
| * @template {T} Тип сервиса | ||||
| */ | ||||
|
cin
|
r9 | export class DescriptorBuilder<S, T, R, U extends keyof S> implements IDescriptorBuilder<S, T, R, U> { | ||
|
cin
|
r5 | private readonly _lifetimeManager: LifetimeManager; | ||
|
cin
|
r0 | private readonly _cb: (d: Descriptor<S, T>) => void; | ||
|
cin
|
r1 | private readonly _eb: (err: unknown) => void; | ||
|
cin
|
r0 | |||
|
cin
|
r9 | private readonly _refs: DepsMap<R>; | ||
|
cin
|
r4 | |||
|
cin
|
r9 | private _lifetime = emptyLifetime<T>(); | ||
|
cin
|
r0 | |||
|
cin
|
r9 | private _overrides: DescriptorMap<S>; | ||
|
cin
|
r0 | |||
| private _cleanup?: (item: T) => void; | ||||
|
cin
|
r9 | private _factory?: (refs: R) => NonNullable<T>; | ||
|
cin
|
r0 | |||
| private _pending = 1; | ||||
| private _failed = false; | ||||
|
cin
|
r1 | private _finalized = false; | ||
| /** | ||||
| * Creates new DescriptorBuilder. Accepts a lifetime container for resolving "container" | ||||
| * lifetime. | ||||
| * | ||||
|
cin
|
r5 | * @param lifetimeManager The lifetime container is the container where the service is to be registered. | ||
|
cin
|
r1 | * @param cb The callback to receive the built service descriptor | ||
| * @param eb The callback to receive the error due | ||||
| */ | ||||
|
cin
|
r5 | constructor(lifetimeManager: LifetimeManager, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) { | ||
| this._lifetimeManager = lifetimeManager; | ||||
|
cin
|
r0 | this._cb = cb; | ||
| this._eb = eb; | ||||
|
cin
|
r1 | this._overrides = {}; | ||
|
cin
|
r4 | this._refs = {}; | ||
|
cin
|
r0 | } | ||
|
cin
|
r9 | |||
| /** Declares dependencies to be consumed in the factory method */ | ||||
| wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X): | ||||
| IDescriptorBuilder<S, T, R & { [k in keyof X]: Resolve<S, X[k]>; }, U> { | ||||
|
cin
|
r4 | |||
| each(refs, (v, k) => this._refs[k] = v); | ||||
| return this as IDescriptorBuilder<S, T, R & { | ||||
|
cin
|
r9 | [k in keyof X]: Resolve<S, X[k]>; | ||
| }, U>; | ||||
|
cin
|
r4 | } | ||
|
cin
|
r9 | |||
| /** Registers a factory method for the service */ | ||||
| factory(f: (refs: R) => NonNullable<T>): void { | ||||
|
cin
|
r4 | this._assertBuilding(); | ||
| this._factory = f; | ||||
| this._finalize(); | ||||
| this._complete(); | ||||
| } | ||||
|
cin
|
r0 | |||
|
cin
|
r1 | private _assertBuilding() { | ||
| if (this._finalized) | ||||
| throw new Error("The descriptor builder is finalized"); | ||||
|
cin
|
r0 | } | ||
|
cin
|
r1 | private _finalize() { | ||
| this._finalized = true; | ||||
| } | ||||
|
cin
|
r0 | |||
|
cin
|
r9 | override<K extends U>(name: K, builder: BuildDescriptorFn<S, NonNullable<S[K]>, U>): this; | ||
| override<K extends U>(services: { [k in K]: BuildDescriptorFn<S, NonNullable<S[k]>, U> }): this; | ||||
| override<K extends U>(nameOrServices: K | { [name in K]: BuildDescriptorFn<S, NonNullable<S[K]>, U> }, builder?: BuildDescriptorFn<S, NonNullable<S[K]>, U>): this { | ||||
|
cin
|
r1 | this._assertBuilding(); | ||
|
cin
|
r0 | const guard = (v: void | Promise<void>) => { | ||
| if (isPromise(v)) | ||||
| v.catch(err => this._fail(err)); | ||||
| }; | ||||
|
cin
|
r9 | if (typeof nameOrServices !== "object") { | ||
|
cin
|
r0 | if (builder) { | ||
| this._defer(); | ||||
|
cin
|
r9 | const d = new DescriptorBuilder<S, NonNullable<S[K]>, object, U>( | ||
|
cin
|
r5 | this._lifetimeManager, | ||
|
cin
|
r0 | result => { | ||
|
cin
|
r1 | this._overrides[nameOrServices] = result; | ||
|
cin
|
r0 | this._complete(); | ||
| }, | ||||
| err => this._fail(err) | ||||
| ); | ||||
| try { | ||||
| guard(builder(d)); | ||||
| } catch (err) { | ||||
| this._fail(err); | ||||
| } | ||||
| } | ||||
| } else { | ||||
| each(nameOrServices, (v, k) => this.override(k, v)); | ||||
| } | ||||
| return this; | ||||
| } | ||||
|
cin
|
r9 | /** Specified the singleton lifetime for the service */ | ||
|
cin
|
r0 | lifetime(lifetime: "singleton", typeId: string): this; | ||
|
cin
|
r9 | /** | ||
| * Specifies the lifetime for the service, either {@linkcode ILifetime<T>} | ||||
| * object or {@linkcode ActivationType} literal. | ||||
| * @param lifetime | ||||
| */ | ||||
|
cin
|
r1 | lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this; | ||
| lifetime(lifetime: ILifetime<T> | ActivationType, typeId?: string): this { | ||||
| this._assertBuilding(); | ||||
|
cin
|
r0 | if (isString(lifetime)) { | ||
| this._lifetime = this._resolveLifetime(lifetime, typeId); | ||||
| } else { | ||||
| this._lifetime = lifetime; | ||||
| } | ||||
| return this; | ||||
| } | ||||
|
cin
|
r9 | /** Registers cleanup callback, used when lifetime of the instance is managed | ||
| * by the container or some external mechanism | ||||
| */ | ||||
|
cin
|
r0 | cleanup(cb: (item: T) => void): this { | ||
|
cin
|
r1 | this._assertBuilding(); | ||
|
cin
|
r0 | this._cleanup = cb; | ||
| return this; | ||||
| } | ||||
|
cin
|
r9 | /** Registers a value as the instance of the service */ | ||
| value(v: NonNullable<T>): void { | ||||
|
cin
|
r1 | this._assertBuilding(); | ||
|
cin
|
r0 | this._cb({ | ||
| activate() { | ||||
| return v; | ||||
| } | ||||
| }); | ||||
|
cin
|
r1 | this._finalize(); | ||
|
cin
|
r0 | } | ||
|
cin
|
r1 | _resolveLifetime<T>(activation: ActivationType, typeId?: string | object): ILifetime<T> { | ||
|
cin
|
r0 | switch (activation) { | ||
| case "container": | ||||
|
cin
|
r5 | return this._lifetimeManager.create(); | ||
|
cin
|
r0 | case "hierarchy": | ||
|
cin
|
r9 | return hierarchyLifetime(); | ||
|
cin
|
r0 | case "context": | ||
|
cin
|
r9 | return contextLifetime(); | ||
|
cin
|
r1 | case "singleton": { | ||
|
cin
|
r0 | if (!typeId) | ||
| throw Error("The singleton activation requires a typeId"); | ||||
| const _oid = isString(typeId) ? typeId : oid(typeId); | ||||
|
cin
|
r9 | return singletonLifetime(_oid); | ||
|
cin
|
r1 | } | ||
|
cin
|
r0 | default: | ||
|
cin
|
r9 | return emptyLifetime(); | ||
|
cin
|
r0 | } | ||
| } | ||||
| _defer() { | ||||
| this._pending++; | ||||
| } | ||||
| _complete() { | ||||
| if (--this._pending === 0) { | ||||
| if (!this._factory) | ||||
| throw new Error("The factory must be specified"); | ||||
| this._cb(new DescriptorImpl<S, T>({ | ||||
| lifetime: this._lifetime, | ||||
|
cin
|
r9 | factory: this._factory as (refs: Record<key, unknown>) => NonNullable<T>, | ||
|
cin
|
r0 | overrides: this._overrides, | ||
| cleanup: this._cleanup | ||||
| })); | ||||
| } | ||||
| } | ||||
|
cin
|
r1 | _fail(err: unknown) { | ||
|
cin
|
r0 | if (!this._failed) { | ||
| this._failed = true; | ||||
| this._eb.call(undefined, err); | ||||
| } | ||||
| } | ||||
| } | ||||