DescriptorBuilder.ts
196 lines
| 6.3 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r4 | import { RegistrationBuilder, LifetimeContainer, ConfigurableKeys, IDescriptorBuilder, Ref, Resolved, DepsMap } from "./interfaces"; | ||
|
cin
|
r1 | import { Descriptor, ILifetime, ActivationType } from "./interfaces"; | ||
| import { DescriptorImpl, RegistrationOverridesMap } from "./DescriptorImpl"; | ||||
|
cin
|
r0 | import { LifetimeManager } from "./LifetimeManager"; | ||
|
cin
|
r4 | import { each, isKey, isPromise, isString, key, oid } from "./traits"; | ||
|
cin
|
r0 | |||
|
cin
|
r1 | /** | ||
| * @template {S} Карта доступных зависимостей, как правило `ContainerServices` | ||||
| * @template {T} Тип сервиса | ||||
| */ | ||||
|
cin
|
r4 | export class DescriptorBuilder<S extends object, T, R extends object = object> implements IDescriptorBuilder<S, T, R> { | ||
|
cin
|
r1 | private readonly _lifetimeContainer: LifetimeContainer; | ||
|
cin
|
r0 | private readonly _cb: (d: Descriptor<S, T>) => void; | ||
|
cin
|
r1 | private readonly _eb: (err: unknown) => void; | ||
|
cin
|
r0 | |||
|
cin
|
r4 | private readonly _refs: DepsMap<key, keyof S>; | ||
|
cin
|
r1 | private _lifetime = LifetimeManager.empty<T>(); | ||
|
cin
|
r0 | |||
|
cin
|
r1 | private _overrides: RegistrationOverridesMap<S>; | ||
|
cin
|
r0 | |||
| private _cleanup?: (item: T) => void; | ||||
|
cin
|
r4 | private _factory?: (refs: R) => 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. | ||||
| * | ||||
| * @param container The lifetime container is the container where the service is to be registered. | ||||
| * @param cb The callback to receive the built service descriptor | ||||
| * @param eb The callback to receive the error due | ||||
| */ | ||||
| constructor(container: LifetimeContainer, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) { | ||||
| this._lifetimeContainer = container; | ||||
|
cin
|
r0 | this._cb = cb; | ||
| this._eb = eb; | ||||
|
cin
|
r1 | this._overrides = {}; | ||
|
cin
|
r4 | this._refs = {}; | ||
|
cin
|
r0 | } | ||
|
cin
|
r4 | wants<X extends { [k in Exclude<key, keyof R>]: keyof S | Ref<keyof S, boolean, unknown>; }>(refs: X): | ||
| IDescriptorBuilder<S, T, R & { | ||||
| [k in keyof X]: | ||||
| X[k] extends keyof S ? NonNullable<S[X[k]]> : | ||||
| X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> : | ||||
| never; | ||||
| }> { | ||||
| each(refs, (v, k) => this._refs[k] = v); | ||||
| return this as IDescriptorBuilder<S, T, R & { | ||||
| [k in keyof X]: | ||||
| X[k] extends keyof S ? NonNullable<S[X[k]]> : | ||||
| X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> : | ||||
| never; | ||||
| }>; | ||||
| } | ||||
| factory(f: (refs: R) => T): void { | ||||
| 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
|
r1 | override<K extends ConfigurableKeys<S>>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this; | ||
| override<K extends ConfigurableKeys<S>>(services: { [k in K]: RegistrationBuilder<S, NonNullable<S[k]>> }): this; | ||||
| override<K extends ConfigurableKeys<S>>(nameOrServices: K | { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }, builder?: RegistrationBuilder<S, NonNullable<S[K]>>): this { | ||||
| this._assertBuilding(); | ||||
|
cin
|
r0 | const guard = (v: void | Promise<void>) => { | ||
| if (isPromise(v)) | ||||
| v.catch(err => this._fail(err)); | ||||
| }; | ||||
|
cin
|
r1 | if (isKey(nameOrServices)) { | ||
|
cin
|
r0 | if (builder) { | ||
| this._defer(); | ||||
|
cin
|
r1 | const d = new DescriptorBuilder<S, NonNullable<S[K]>>( | ||
| this._lifetimeContainer, | ||||
|
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; | ||||
| } | ||||
| lifetime(lifetime: "singleton", typeId: string): this; | ||||
|
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; | ||||
| } | ||||
| cleanup(cb: (item: T) => void): this { | ||||
|
cin
|
r1 | this._assertBuilding(); | ||
|
cin
|
r0 | this._cleanup = cb; | ||
| return this; | ||||
| } | ||||
|
cin
|
r4 | /*factory(f: (resolve: Resolver<S>) => T): void { | ||
|
cin
|
r1 | this._assertBuilding(); | ||
|
cin
|
r0 | this._factory = f; | ||
|
cin
|
r1 | this._finalize(); | ||
|
cin
|
r0 | this._complete(); | ||
|
cin
|
r4 | }*/ | ||
|
cin
|
r0 | |||
| value(v: 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
|
r1 | return LifetimeManager.containerLifetime(this._lifetimeContainer); | ||
|
cin
|
r0 | case "hierarchy": | ||
| return LifetimeManager.hierarchyLifetime(); | ||||
| case "context": | ||||
| return LifetimeManager.contextLifetime(); | ||||
|
cin
|
r1 | case "singleton": { | ||
|
cin
|
r0 | if (!typeId) | ||
| throw Error("The singleton activation requires a typeId"); | ||||
| const _oid = isString(typeId) ? typeId : oid(typeId); | ||||
| return LifetimeManager.singletonLifetime(_oid); | ||||
|
cin
|
r1 | } | ||
|
cin
|
r0 | default: | ||
| return LifetimeManager.empty(); | ||||
| } | ||||
| } | ||||
| _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, | ||||
| factory: this._factory, | ||||
| overrides: this._overrides, | ||||
| cleanup: this._cleanup | ||||
| })); | ||||
| } | ||||
| } | ||||
|
cin
|
r1 | _fail(err: unknown) { | ||
|
cin
|
r0 | if (!this._failed) { | ||
| this._failed = true; | ||||
| this._eb.call(undefined, err); | ||||
| } | ||||
| } | ||||
| } | ||||