Container.ts
263 lines
| 8.2 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r33 | import { ActivationContext } from "./ActivationContext"; | ||
|
cin
|
r34 | import { ValueDescriptor } from "./ValueDescriptor"; | ||
| import { ActivationError } from "./ActivationError"; | ||||
|
cin
|
r38 | import { isDescriptor, ActivationType, ServiceMap, isDependencyRegistration, isValueRegistration, ServiceRegistration } from "./interfaces"; | ||
|
cin
|
r34 | import { AggregateDescriptor } from "./AggregateDescriptor"; | ||
| import { isPrimitive } from "../safe"; | ||||
| import { ReferenceDescriptor } from "./ReferenceDescriptor"; | ||||
|
cin
|
r38 | import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor"; | ||
| import { ModuleResolverBase } from "./ModuleResolverBase"; | ||||
| import format = require("../text/format"); | ||||
|
cin
|
r33 | |||
| export class Container { | ||||
|
cin
|
r38 | _services: ServiceMap; | ||
|
cin
|
r33 | |||
|
cin
|
r38 | _cache: object; | ||
| _cleanup: (() => void)[]; | ||||
|
cin
|
r33 | |||
|
cin
|
r38 | _root: Container; | ||
|
cin
|
r33 | |||
|
cin
|
r38 | _parent: Container; | ||
|
cin
|
r33 | |||
|
cin
|
r38 | _resolver: ModuleResolverBase; | ||
|
cin
|
r33 | |||
| constructor(parent?: Container) { | ||||
| this._parent = parent; | ||||
| this._services = parent ? Object.create(parent._services) : {}; | ||||
| this._cache = {}; | ||||
| this._cleanup = []; | ||||
| this._root = parent ? parent.getRootContainer() : this; | ||||
| this._services.container = new ValueDescriptor(this); | ||||
| } | ||||
| getRootContainer() { | ||||
| return this._root; | ||||
| } | ||||
| getParent() { | ||||
| return this._parent; | ||||
| } | ||||
| getService<T = any>(name: string, def?: T) { | ||||
|
cin
|
r38 | const d = this._services[name]; | ||
|
cin
|
r33 | if (!d) | ||
| if (arguments.length > 1) | ||||
| return def; | ||||
| else | ||||
| throw new Error("Service '" + name + "' isn't found"); | ||||
| if (d.isInstanceCreated()) | ||||
|
cin
|
r38 | return d.getInstance() as T; | ||
|
cin
|
r33 | |||
|
cin
|
r38 | const context = new ActivationContext(this, this._services); | ||
|
cin
|
r33 | |||
| try { | ||||
|
cin
|
r38 | return d.activate(context, name) as T; | ||
|
cin
|
r33 | } catch (error) { | ||
| throw new ActivationError(name, context.getStack(), error); | ||||
| } | ||||
| } | ||||
| register(nameOrCollection, service?) { | ||||
|
cin
|
r38 | if (arguments.length === 1) { | ||
| const data = nameOrCollection; | ||||
| for (const name in data) | ||||
|
cin
|
r33 | this.register(name, data[name]); | ||
| } else { | ||||
|
cin
|
r34 | if (!(isDescriptor(service))) | ||
|
cin
|
r33 | service = new ValueDescriptor(service); | ||
| this._services[nameOrCollection] = service; | ||||
| } | ||||
| return this; | ||||
| } | ||||
| onDispose(callback) { | ||||
| if (!(callback instanceof Function)) | ||||
| throw new Error("The callback must be a function"); | ||||
| this._cleanup.push(callback); | ||||
| } | ||||
| dispose() { | ||||
| if (this._cleanup) { | ||||
|
cin
|
r38 | for (const f of this._cleanup) | ||
| f(); | ||||
|
cin
|
r33 | this._cleanup = null; | ||
| } | ||||
| } | ||||
| /** | ||||
| * @param{String|Object} config | ||||
| * The configuration of the contaier. Can be either a string or an object, | ||||
| * if the configuration is an object it's treated as a collection of | ||||
| * services which will be registed in the contaier. | ||||
|
cin
|
r38 | * | ||
|
cin
|
r33 | * @param{Function} opts.contextRequire | ||
| * The function which will be used to load a configuration or types for services. | ||||
|
cin
|
r38 | * | ||
|
cin
|
r33 | */ | ||
|
cin
|
r38 | async configure(config: string | object, opts?: object) { | ||
|
cin
|
r33 | if (typeof (config) === "string") { | ||
|
cin
|
r38 | const resolver = await this._resolver.createResolver(config, opts); | ||
| const data = await this._resolver.loadModule(config); | ||||
| return this._configure(data, { resolver }); | ||||
|
cin
|
r33 | } else { | ||
|
cin
|
r38 | return this._configure(config); | ||
|
cin
|
r33 | } | ||
| } | ||||
| createChildContainer() { | ||||
| return new Container(this); | ||||
| } | ||||
| has(id) { | ||||
| return id in this._cache; | ||||
| } | ||||
| get(id) { | ||||
| return this._cache[id]; | ||||
| } | ||||
| store(id, value) { | ||||
| return (this._cache[id] = value); | ||||
| } | ||||
|
cin
|
r38 | async _configure(data: object, opts?: { resolver: ModuleResolverBase }) { | ||
| const resolver = (opts && opts.resolver) || this._resolver; | ||||
| const services: ServiceMap = {}; | ||||
|
cin
|
r33 | |||
|
cin
|
r38 | resolver.beginBatch(); | ||
|
cin
|
r33 | |||
|
cin
|
r38 | async function parse(k) { | ||
| services[k] = await this._parse(data[k], resolver); | ||||
|
cin
|
r33 | } | ||
|
cin
|
r38 | const batch = Object.keys(data).map(parse); | ||
|
cin
|
r33 | |||
|
cin
|
r38 | resolver.completeBatch(); | ||
|
cin
|
r33 | |||
|
cin
|
r38 | await Promise.all(batch); | ||
|
cin
|
r33 | |||
|
cin
|
r38 | this.register(services); | ||
|
cin
|
r33 | } | ||
|
cin
|
r38 | async _parse(registration: any, resolver: ModuleResolverBase) { | ||
| if (isPrimitive(registration) || isDescriptor(registration)) | ||||
| return registration; | ||||
| if (isDependencyRegistration(registration)) { | ||||
|
cin
|
r33 | return new ReferenceDescriptor( | ||
|
cin
|
r38 | registration.$dependency, | ||
| registration.lazy, | ||||
| registration.optional, | ||||
| registration["default"], | ||||
| registration.services && this._parseObject(registration.services, resolver) | ||||
| ); | ||||
| } else if (isValueRegistration(registration)) { | ||||
| return !registration.parse ? | ||||
| new ValueDescriptor(registration.$value) : | ||||
| new AggregateDescriptor(this._parse(registration.$value, resolver)); | ||||
| } else if (registration.$type || registration.$factory) { | ||||
| return this._parseService(registration, resolver); | ||||
| } else if (registration instanceof Array) { | ||||
| return this._parseArray(registration, resolver); | ||||
|
cin
|
r33 | } | ||
|
cin
|
r38 | return this._parseObject(registration, resolver); | ||
|
cin
|
r33 | } | ||
|
cin
|
r38 | async _parseService(data: ServiceRegistration, resolver: ModuleResolverBase) { | ||
| const opts: ServiceDescriptorParams = { | ||||
| owner: this | ||||
| }; | ||||
|
cin
|
r33 | |||
|
cin
|
r38 | function guard<T>(fn: () => PromiseLike<T>) { | ||
| return fn(); | ||||
|
cin
|
r33 | } | ||
|
cin
|
r38 | if (data.$type) { | ||
| if (data.$type instanceof Function) | ||||
| opts.type = data.$type; | ||||
| else if (typeof data.$type === "string") | ||||
| opts.type = await resolver.resolve(data.$type); | ||||
| else | ||||
| throw new Error(format("Unsupported type specification: {0:json}", data.$type)); | ||||
| } else { | ||||
| if (data.$factory instanceof Function) | ||||
| opts.factory = data.$factory; | ||||
| else if (typeof data.$factory === "string") | ||||
| opts.factory = await resolver.resolve(data.$factory); | ||||
| else | ||||
| throw new Error(format("Unsupported factory specification: {0:json}", data.$factory)); | ||||
| } | ||||
|
cin
|
r33 | |||
| if (data.services) | ||||
|
cin
|
r38 | opts.services = await this._parseObject(data.services, resolver); | ||
| if (data.inject instanceof Array) | ||||
| opts.inject = await Promise.all(data.inject.map(x => this._parseObject(x, resolver))); | ||||
| else | ||||
| opts.inject = this._parseObject(data.inject, resolver); | ||||
|
cin
|
r33 | if (data.params) | ||
|
cin
|
r38 | opts.params = this._parse(data.params, resolver); | ||
|
cin
|
r33 | |||
| if (data.activation) { | ||||
| if (typeof (data.activation) === "string") { | ||||
| switch (data.activation.toLowerCase()) { | ||||
| case "singleton": | ||||
|
cin
|
r38 | opts.activation = ActivationType.Singleton; | ||
|
cin
|
r33 | break; | ||
| case "container": | ||||
|
cin
|
r38 | opts.activation = ActivationType.Container; | ||
|
cin
|
r33 | break; | ||
| case "hierarchy": | ||||
|
cin
|
r38 | opts.activation = ActivationType.Hierarchy; | ||
|
cin
|
r33 | break; | ||
| case "context": | ||||
|
cin
|
r38 | opts.activation = ActivationType.Context; | ||
|
cin
|
r33 | break; | ||
| case "call": | ||||
|
cin
|
r38 | opts.activation = ActivationType.Call; | ||
|
cin
|
r33 | break; | ||
| default: | ||||
| throw new Error("Unknown activation type: " + | ||||
| data.activation); | ||||
| } | ||||
| } else { | ||||
| opts.activation = Number(data.activation); | ||||
| } | ||||
| } | ||||
| if (data.cleanup) | ||||
| opts.cleanup = data.cleanup; | ||||
| return new ServiceDescriptor(opts); | ||||
| } | ||||
|
cin
|
r38 | _parseObject(data: any, typemap) { | ||
|
cin
|
r33 | if (data.constructor && | ||
| data.constructor.prototype !== Object.prototype) | ||||
| return new ValueDescriptor(data); | ||||
|
cin
|
r38 | const o = {}; | ||
|
cin
|
r33 | |||
|
cin
|
r38 | for (const p in data) | ||
|
cin
|
r33 | o[p] = this._parse(data[p], typemap); | ||
| return o; | ||||
| } | ||||
| _parseArray(data, typemap) { | ||||
| if (data.constructor && | ||||
| data.constructor.prototype !== Array.prototype) | ||||
| return new ValueDescriptor(data); | ||||
|
cin
|
r38 | return data.map(x => this._parse(x, typemap)); | ||
|
cin
|
r33 | } | ||
|
cin
|
r38 | } | ||