Container.ts
172 lines
| 6.1 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r49 | import { ActivationContext } from "./ActivationContext"; | ||
| import { ValueDescriptor } from "./ValueDescriptor"; | ||||
| import { ActivationError } from "./ActivationError"; | ||||
|
cin
|
r135 | import { ServiceMap, Descriptor, PartialServiceMap, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces"; | ||
|
cin
|
r49 | import { TraceSource } from "../log/TraceSource"; | ||
|
cin
|
r120 | import { Configuration, RegistrationMap } from "./Configuration"; | ||
|
cin
|
r49 | import { Cancellation } from "../Cancellation"; | ||
|
cin
|
r142 | import { IDestroyable, PromiseOrValue, ICancellation } from "../interfaces"; | ||
|
cin
|
r118 | import { isDescriptor } from "./traits"; | ||
|
cin
|
r131 | import { LifetimeManager } from "./LifetimeManager"; | ||
|
cin
|
r142 | import { each, isString } from "../safe"; | ||
| import { ContainerConfiguration, FluentRegistrations } from "./fluent/interfaces"; | ||||
|
cin
|
r135 | import { FluentConfiguration } from "./fluent/FluentConfiguration"; | ||
|
cin
|
r49 | |||
| const trace = TraceSource.get("@implab/core/di/ActivationContext"); | ||||
|
cin
|
r133 | export class Container<S extends object = any> implements ServiceLocator<S>, IDestroyable { | ||
|
cin
|
r120 | readonly _services: ContainerServiceMap<S>; | ||
|
cin
|
r49 | |||
|
cin
|
r135 | readonly _lifetimeManager: LifetimeManager; | ||
|
cin
|
r131 | |||
|
cin
|
r114 | readonly _cleanup: (() => void)[]; | ||
|
cin
|
r49 | |||
|
cin
|
r114 | readonly _root: Container<S>; | ||
|
cin
|
r49 | |||
|
cin
|
r114 | readonly _parent?: Container<S>; | ||
|
cin
|
r49 | |||
|
cin
|
r114 | _disposed: boolean; | ||
|
cin
|
r49 | |||
|
cin
|
r114 | constructor(parent?: Container<S>) { | ||
|
cin
|
r49 | this._parent = parent; | ||
| this._services = parent ? Object.create(parent._services) : {}; | ||||
| this._cleanup = []; | ||||
| this._root = parent ? parent.getRootContainer() : this; | ||||
|
cin
|
r115 | this._services.container = new ValueDescriptor(this) as any; | ||
|
cin
|
r114 | this._disposed = false; | ||
|
cin
|
r131 | this._lifetimeManager = new LifetimeManager(); | ||
|
cin
|
r49 | } | ||
| getRootContainer() { | ||||
| return this._root; | ||||
| } | ||||
| getParent() { | ||||
| return this._parent; | ||||
| } | ||||
|
cin
|
r131 | getLifetimeManager() { | ||
| return this._lifetimeManager; | ||||
| } | ||||
|
cin
|
r133 | resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K> { | ||
|
cin
|
r49 | trace.debug("resolve {0}", name); | ||
| const d = this._services[name]; | ||||
| if (d === undefined) { | ||||
|
cin
|
r114 | if (def !== undefined) | ||
|
cin
|
r49 | return def; | ||
| else | ||||
| throw new Error("Service '" + name + "' isn't found"); | ||||
|
cin
|
r114 | } else { | ||
|
cin
|
r49 | |||
|
cin
|
r131 | const context = new ActivationContext<S>(this, this._services, String(name), d); | ||
|
cin
|
r114 | try { | ||
|
cin
|
r131 | return d.activate(context); | ||
|
cin
|
r114 | } catch (error) { | ||
| throw new ActivationError(name.toString(), context.getStack(), error); | ||||
| } | ||||
|
cin
|
r49 | } | ||
| } | ||||
| /** | ||||
| * @deprecated use resolve() method | ||||
| */ | ||||
|
cin
|
r133 | getService<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>) { | ||
|
cin
|
r114 | return this.resolve(name, def); | ||
|
cin
|
r49 | } | ||
|
cin
|
r115 | register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this; | ||
| register(services: PartialServiceMap<S>): this; | ||||
| register<K extends keyof S>(nameOrCollection: K | ServiceMap<S>, service?: Descriptor<S, S[K]>) { | ||||
|
cin
|
r49 | if (arguments.length === 1) { | ||
|
cin
|
r114 | const data = nameOrCollection as ServiceMap<S>; | ||
|
cin
|
r115 | |||
|
cin
|
r131 | each(data, (v, k) => this.register(k, v)); | ||
|
cin
|
r49 | } else { | ||
| if (!isDescriptor(service)) | ||||
| throw new Error("The service parameter must be a descriptor"); | ||||
|
cin
|
r115 | this._services[nameOrCollection as K] = service as any; | ||
|
cin
|
r49 | } | ||
| return this; | ||||
| } | ||||
|
cin
|
r114 | onDispose(callback: () => void) { | ||
|
cin
|
r49 | if (!(callback instanceof Function)) | ||
| throw new Error("The callback must be a function"); | ||||
| this._cleanup.push(callback); | ||||
| } | ||||
|
cin
|
r129 | destroy() { | ||
| return this.dispose(); | ||||
| } | ||||
|
cin
|
r49 | dispose() { | ||
|
cin
|
r114 | if (this._disposed) | ||
| return; | ||||
| this._disposed = true; | ||||
| for (const f of this._cleanup) | ||||
| f(); | ||||
|
cin
|
r49 | } | ||
| /** | ||||
| * @param{String|Object} config | ||||
|
cin
|
r136 | * The configuration of the container. Can be either a string or an object, | ||
|
cin
|
r49 | * if the configuration is an object it's treated as a collection of | ||
|
cin
|
r136 | * services which will be registered in the container. | ||
|
cin
|
r49 | * | ||
| * @param{Function} opts.contextRequire | ||||
| * The function which will be used to load a configuration or types for services. | ||||
| * | ||||
| */ | ||||
|
cin
|
r136 | async configure(config: string | RegistrationMap<S>, opts?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) { | ||
| const _opts = Object.create(opts || null); | ||||
|
cin
|
r49 | |||
| if (typeof (config) === "string") { | ||||
|
cin
|
r136 | _opts.baseModule = config; | ||
| const module = await import(config); | ||||
| if (module && module.default && typeof (module.default.apply) === "function") | ||||
| return module.default.apply(this); | ||||
| else | ||||
| return this._applyLegacyConfig(module, _opts, ct); | ||||
|
cin
|
r49 | } else { | ||
|
cin
|
r136 | return this._applyLegacyConfig(config, _opts, ct); | ||
|
cin
|
r49 | } | ||
| } | ||||
|
cin
|
r142 | applyConfig<S2 extends object>(config: Promise<{ default: ContainerConfiguration<S2>; }>, ct?: ICancellation): Promise<Container<S & S2>>; | ||
| applyConfig<S2 extends object, P extends string>(config: Promise<{ [p in P]: ContainerConfiguration<S2>; }>, prop: P, ct?: ICancellation): Promise<Container<S & S2>>; | ||||
| async applyConfig<S2 extends object, P extends string>( | ||||
| config: Promise<{ [p in P | "default"]: ContainerConfiguration<S2>; }>, | ||||
| propOrCt?: P | ICancellation, | ||||
| ct?: ICancellation | ||||
| ): Promise<Container<S & S2>> { | ||||
| const mod = await config; | ||||
| let _ct: ICancellation; | ||||
| let _prop: P | "default"; | ||||
| if (isString(propOrCt)) { | ||||
| _prop = propOrCt; | ||||
| _ct = ct || Cancellation.none; | ||||
| } else { | ||||
| _ct = propOrCt || Cancellation.none; | ||||
| _prop = "default"; | ||||
| } | ||||
| return mod[_prop].apply(this, _ct); | ||||
| } | ||||
|
cin
|
r136 | async _applyLegacyConfig(config: RegistrationMap<S>, opts: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) { | ||
| return new Configuration<S>(this).applyConfiguration(config, opts); | ||||
| } | ||||
|
cin
|
r135 | async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> { | ||
| await new FluentConfiguration<S>().register(config).apply(this, ct); | ||||
| return this; | ||||
| } | ||||
|
cin
|
r120 | createChildContainer<S2 extends object = S>(): Container<S & S2> { | ||
|
cin
|
r114 | return new Container<S & S2>(this as any); | ||
|
cin
|
r49 | } | ||
| } | ||||